> For the complete documentation index, see [llms.txt](https://docs.tnid.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.tnid.com/api-reference/003_definitions/types.md).

# Types

## Address

**Schema:** user, company

```graphql
type Address {
  "City of the address"
  city: String
  "Country of the address"
  country: String
  "The unique identifier of the address"
  id: Id!
  "State of the address"
  state: String
  "Street of the address"
  street: String
  "Types of the address"
  types: [AddressType]
  visibility: [VisibilityType]
  "Zip code of the address"
  zip_code: String
}
```

## AiTask

**Schema:** user, company

A prompt run against the documents a task watches, producing a structured result for each

```graphql
type AiTask {
  "How many documents this task covers"
  document_count: Integer!
  "The folders the task watches, each covering everything beneath it. Empty alongside a false `run_on_root` is a task that runs only against the documents a run names"
  folders: [Folder!]!
  id: Id!
  "Runs of this task that haven't finished — queued or being answered now"
  in_flight_count: Integer!
  inserted_at: Datetime!
  "What the owner calls this task"
  name: String!
  "The answer's shape, written as an example: names to types, where a value may be an object or a one-element list describing a repeated entry"
  output_shape: Json!
  "The owner's instructions"
  prompt: String!
  "Whether the task watches the whole repository, whatever folders it holds now or later"
  run_on_root: Boolean!
  updated_at: Datetime!
}
```

## AiTaskRun

**Schema:** user, company

One run of a task against a document, with the document's name alongside

```graphql
type AiTaskRun {
  document_id: Id!
  "Why the run ended without an answer"
  error: String
  "The document this answer is about"
  file_name: String
  id: Id!
  inserted_at: Datetime!
  "The shape as it was when this ran"
  output_shape: Json!
  "The instructions as they were when this ran"
  prompt: String!
  "When the model answered. Null while a run is still going, and on one that ended without reaching the model at all"
  ran_at: Datetime
  "The extracted values, keyed by field name. Null until the run completes"
  result: Json
  status: AiTaskRunStatus!
  task_id: Id!
}
```

## B2bConnection

**Schema:** company

```graphql
type B2bConnection {
  "The company that initiated the connection"
  company: Company
  "The company that is connected"
  connected_company: Company
  "The date and time the connection was created"
  created_at: NaiveDatetime
  "The unique identifier of the B2B connection"
  id: Id
  "The date and time the connection was started"
  started_at: NaiveDatetime
  "The type of the connection"
  type: B2bConnectionType
  "The date and time the connection was last updated"
  updated_at: NaiveDatetime
}
```

## B2bConnectionRequest

**Schema:** company

```graphql
type B2bConnectionRequest {
  "The company that initiated the request"
  company: Company
  "The unique identifier of the request"
  id: Id
  "The time the request was created"
  inserted_at: NaiveDatetime
  "The company that was invited"
  invited_company: Company
  "The time the request was responded to"
  responded_at: NaiveDatetime
  "The status of the request"
  status: ConnectionStatus
  "The type of the connection"
  type: B2bConnectionType
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who initiated the request (if any)"
  user: User
}
```

## B2bFormSubmissionRequest

**Schema:** company

A B2B form submission request — company requests another company to fill a form

```graphql
type B2bFormSubmissionRequest {
  form: FormRequestInfo
  form_instance: FormInstance
  id: Id!
  inserted_at: NaiveDatetime!
  requester: Company
  submitter: Company
  updated_at: NaiveDatetime!
}
```

## B2cConnection

**Schema:** user, company

A connection between a company (business) and a user (individual)

```graphql
type B2cConnection {
  "The company that initiated the connection"
  company: Company
  "The user that accepted the connected"
  connected_user: User
  "The unique identifier of the connection"
  id: Id
  "The time the connection was created"
  inserted_at: NaiveDatetime
  "The time the connection was started at"
  started_at: NaiveDatetime
  "The type of the connection"
  type: B2cConnectionType
  "The time the connection was last updated"
  updated_at: NaiveDatetime
}
```

## B2cConnectionNotificationSettings

**Schema:** user

Notification settings for a user's connection to a specific company (B2C connection)

```graphql
type B2cConnectionNotificationSettings {
  "Email when a B2B connection request is received on behalf of the company"
  b2b_conn_request_received_email: Boolean!
  "Email when a B2B connection request response is received on behalf of the company"
  b2b_conn_request_response_email: Boolean!
  "Email when a B2B form submission request is received on behalf of the company"
  b2b_form_instance_submission_request_received_email: Boolean!
  "Email when a B2C connection request response is received on behalf of the company"
  b2c_conn_request_response_email: Boolean!
  "Email when a B2C subscription request response is received on behalf of the company"
  b2c_sub_request_response_email: Boolean!
  "Email when a C2B connection request is received on behalf of the company"
  c2b_conn_request_received_email: Boolean!
  "Email when a company website or social network status changes"
  company_social_network_status_change_email: Boolean!
  "The ID of the B2C connection"
  id: Id!
}
```

## B2cConnectionRequest

**Schema:** user, company

```graphql
type B2cConnectionRequest {
  "The company that initiated the request"
  company: Company
  "The unique identifier of the request"
  id: Id
  "The time the request was created"
  inserted_at: NaiveDatetime
  "The user that was invited"
  invited_user: User
  "The time the request was responded to"
  responded_at: NaiveDatetime
  "The status of the request"
  status: ConnectionStatus
  "The type of the connection"
  type: B2cConnectionType
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who initiated the request (if any)"
  user: User
}
```

## B2cEmailSubscription

**Schema:** user, company

A user's subscription to company notifications.

```graphql
type B2cEmailSubscription {
  "The company that the subscription belongs to"
  company: Company
  "The registered email, where to send notifications to."
  email: String!
  "Expiration date of subscription"
  expiration_date: Date
  "The unique identifier of the subscription"
  id: Id!
  "The time the request was created"
  inserted_at: NaiveDatetime
  "End time for notificaiton sending"
  notification_end_time: Time
  "Start time for notification sending"
  notification_start_time: Time
  "The topics the user is subscribed to"
  subscription_topics: [String!]!
  "The timezone used for sending notifications"
  timezone: String
  "The type of the subscription - always EMAIL in this case"
  type: B2cSubscriptionType!
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who subscribed to the company"
  user: User
}
```

## B2cFormSubmissionRequest

**Schema:** user, company

A B2C form submission request — company requests a user to fill a form

```graphql
type B2cFormSubmissionRequest {
  form: FormRequestInfo
  form_instance: FormInstance
  id: Id!
  inserted_at: NaiveDatetime!
  requester: Company
  submitter: User
  updated_at: NaiveDatetime!
}
```

## B2cSmsSubscription

**Schema:** user, company

A user's subscription to company notifications.

```graphql
type B2cSmsSubscription {
  "The company that the subscription belongs to"
  company: Company
  "Expiration date of subscription"
  expiration_date: Date
  "The unique identifier of the subscription"
  id: Id!
  "The time the request was created"
  inserted_at: NaiveDatetime
  "End time for notificaiton sending"
  notification_end_time: Time
  "Start time for notification sending"
  notification_start_time: Time
  "The topics the user is subscribed to"
  subscription_topics: [String!]!
  "The registered telephone_number, where to send notifications to."
  telephone_number: String!
  "The timezone used for sending notifications"
  timezone: String
  "The type of the subscription - always SMS in this case"
  type: B2cSubscriptionType!
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who subscribed to the company"
  user: User
}
```

## B2cSubscriptionRequest

**Schema:** user, company

```graphql
type B2cSubscriptionRequest {
  "The company that initiated the request"
  company: Company
  "The unique identifier of the request"
  id: Id
  "The time the request was created"
  inserted_at: NaiveDatetime
  "The user that was invited"
  invited_user: User
  "The time the request was responded to"
  responded_at: NaiveDatetime
  "The status of the request"
  status: SubscriptionRequestStatus
  "Type of the subscription: Email, SMS, or Voice"
  type: B2cSubscriptionType
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who initiated the request (if any)"
  user: User
}
```

## B2cSubscriptionTopic

**Schema:** user, company

The company topic that users can subscribe to

```graphql
type B2cSubscriptionTopic {
  "The description of the B2C subscription topic"
  description: String
  "Whether email is enabled for the topic or not"
  enable_email: Boolean!
  "Whether sms is enabled for the topic or not"
  enable_sms: Boolean!
  "Whether voice is enabled for the topic or not"
  enable_voice: Boolean!
  "The unique identifier of the B2C subscription topic"
  id: Id!
  "The name of the B2C subscription topic"
  name: String!
  "The type of the B2C subscription topic"
  type: B2cSubscriptionTopicType!
}
```

## B2cVoiceSubscription

**Schema:** user, company

A user's subscription to company notifications.

```graphql
type B2cVoiceSubscription {
  "The company that the subscription belongs to"
  company: Company
  "Expiration date of subscription"
  expiration_date: Date
  "The unique identifier of the subscription"
  id: Id!
  "The time the request was created"
  inserted_at: NaiveDatetime
  "End time for notificaiton sending"
  notification_end_time: Time
  "Start time for notification sending"
  notification_start_time: Time
  "The topics the user is subscribed to"
  subscription_topics: [String!]!
  "The registered telephone_number, where to send notifications to."
  telephone_number: String!
  "The timezone used for sending notifications"
  timezone: String
  "The type of the subscription - always VOICE in this case"
  type: B2cSubscriptionType!
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who subscribed to the company"
  user: User
}
```

## BulkStatusResponse

**Schema:** user, company

Response for a bulk action — the status plus how many records it actually affected. Bulk actions are best-effort: ids that don't exist, aren't the caller's, or aren't in a state the action applies to are skipped rather than failing the batch

```graphql
type BulkStatusResponse {
  "How many records the action actually affected"
  count: Integer
  "Status of the request"
  status: ResponseStatus
}
```

## C2bConnectionRequest

**Schema:** user, company

```graphql
type C2bConnectionRequest {
  "The unique identifier of the request"
  id: Id
  "The time the request was created"
  inserted_at: NaiveDatetime
  "The company that received the request"
  invited_company: Company
  "The time the request was responded to"
  responded_at: NaiveDatetime
  "The user that responded to the request"
  responded_by_user: User
  "The status of the request"
  status: ConnectionStatus
  "The type of the connection"
  type: B2cConnectionType
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who initiated the request (if any)"
  user: User
}
```

## C2cConnection

**Schema:** user

A connection between a user (individual) and another user (individual)

```graphql
type C2cConnection {
  "The user that accepted the connection"
  connected_user: User
  "The unique identifier of the connection"
  id: Id
  "The time the connection was created"
  inserted_at: NaiveDatetime
  "The time the connection was started at"
  started_at: NaiveDatetime
  "The type of the connection"
  type: C2cConnectionType
  "The time the connection was last updated"
  updated_at: NaiveDatetime
  "The user that initiated the connection"
  user: User
}
```

## C2cConnectionRequest

**Schema:** user

```graphql
type C2cConnectionRequest {
  "The unique identifier of the request"
  id: Id
  "The time the request was created"
  inserted_at: NaiveDatetime
  "The user that was invited"
  invited_user: User
  "The time the request was responded to"
  responded_at: NaiveDatetime
  "The status of the request"
  status: ConnectionStatus
  "The type of the connection"
  type: C2cConnectionType
  "The time the request was last updated"
  updated_at: NaiveDatetime
  "The user who initiated the request (if any)"
  user: User
}
```

## ClientSecret

**Schema:** user, company

```graphql
type ClientSecret {
  "Client secret id"
  client_id: String
  "Client secret value, only returned upon creation"
  client_secret: String
  "Client secret description"
  description: String
  "Unique identifier of the client secret record"
  id: Id!
  "When the client secret was created"
  inserted_at: NaiveDatetime
}
```

## Company

**Schema:** user, company

```graphql
type Company {
  "The about us of the company"
  about_us: String
  "About us visibility of the company"
  about_us_visibility: [VisibilityType]
  "The addresses of the company"
  addresses: [Address]
  "B2C relation visibility of the company"
  b2c_visibility: [VisibilityType]
  "The brand name of the company"
  brand_name: String
  "Brand name visibility of the company"
  brand_name_visibility: [VisibilityType]
  "Client secret of the company, only returned on creation"
  client_secret: ClientSecret
  "The viewer's connection state to this company (drives the company-view actions area)"
  connection: ViewerConnection
  "The maximum total bytes the company's document repository may occupy; only the company itself can read it (string — see above)"
  document_repository_byte_limit: String
  "The dedicated email address that files can be sent to for this company's document repository"
  document_repository_email_address: String
  "The phone number that files can be texted (SMS/MMS) to for the document repository (digits only, no leading +)"
  document_repository_phone_number: String
  "Total bytes the company's documents currently occupy, trash included; only the company itself can read it (string — a byte count can exceed a 32-bit integer)"
  document_repository_used_bytes: String
  "The emails of the company"
  emails: [Email]
  "The forms published by the company, filtered to those the viewer may see"
  forms: [Form]
  "The unique identifier of the company"
  id: String!
  "The legal name of the company"
  legal_name: String
  "Legal name visibility of the company"
  legal_name_visibility: [VisibilityType]
  "The logo of the company"
  logo_url: String
  "Logo url visibility of the company"
  logo_url_visibility: [VisibilityType]
  "Additional metadata"
  metadata: Json
  "Metadata visibility of the company"
  metadata_visibility: [VisibilityType]
  "The organization type of the company"
  organization_type: OrganizationType
  "Organization type visibility of the company"
  organization_type_visibility: [VisibilityType]
  "The TnID profile name of the company"
  profile_name: String!
  "A key/value storage for private data"
  secret_storage: Json
  "The social networks of the company"
  social_networks: [Webpage]
  "The specialties of the company"
  specialties: [Specialty]
  "Specialties visibility of the company"
  specialties_visibility: [VisibilityType]
  "Subscription settings of the company, enabled and disabled channels"
  subscription_settings: CompanySubscriptionSettings
  "Subscription topics that company offers"
  subscription_topics: [B2cSubscriptionTopic]
  "The tax IDs of the company"
  tax_ids: [CompanyTaxId]
  "The telephone numbers of the company"
  telephone_numbers: [TelephoneNumber]
  "Trusted domains of the company"
  trusted_domains: [TrustedDomain]
  "QR code (inline SVG data-URI) encoding the company's public vCard URL, for preview"
  vcard_qr_code: String
  "Download-ready PNG data-URI of the vCard QR code (carries the company-name header)"
  vcard_qr_code_download: String
  "The verification status of the company"
  verified: Boolean
  "The vertical type of the company"
  vertical_type: VerticalType
  "Vertical type visibility of the company"
  vertical_type_visibility: [VisibilityType]
  "The webpages of the company"
  webpages: [Webpage]
  "The foundation year of the company"
  year_founded: Integer
  "Year of foundation visibility of the company"
  year_founded_visibility: [VisibilityType]
}
```

## CompanyDashboardStats

**Schema:** company

Aggregated dashboard statistics for a company

```graphql
type CompanyDashboardStats {
  "Total number of established B2B connections"
  b2b_connections_count: Integer!
  "Total number of established B2C connections"
  b2c_connections_count: Integer!
  "Number of pending received B2B connection requests"
  pending_b2b_connection_requests_count: Integer!
  "Number of pending received C2B (user-to-company) connection requests"
  pending_c2b_connection_requests_count: Integer!
}
```

## CompanyPendingActionCounts

**Schema:** company

Counts of items awaiting the current company's response

```graphql
type CompanyPendingActionCounts {
  "Company connection requests received and not yet answered"
  company_connection_requests: Integer!
  "Form submission requests waiting on this company: those not yet started,
and those returned with changes requested. Requests already submitted,
settled or in progress are excluded."
  form_requests: Integer!
  "Documents received over a message channel and awaiting confirmation"
  pending_documents: Integer!
  "People connection requests received and not yet answered"
  people_connection_requests: Integer!
}
```

## CompanyProfileSuggestionAddress

**Schema:** company

An address suggestion for a company profile

```graphql
type CompanyProfileSuggestionAddress {
  "City part of the address"
  city: String
  "Country part of the address"
  country: String
  "Street part of the address"
  street: String
  "Zip / postal code part of the address"
  zip_code: String
}
```

## CompanyProfileSuggestionEmail

**Schema:** company

An email suggestion for a company profile

```graphql
type CompanyProfileSuggestionEmail {
  "Email address"
  email: String
}
```

## CompanyProfileSuggestionSocialNetwork

**Schema:** company

A social network URL suggestion for a company profile

```graphql
type CompanyProfileSuggestionSocialNetwork {
  "Social network type (e.g. facebook, instagram, linkedin, x)"
  type: String
  "Full URL to the social network page"
  url: String
}
```

## CompanyProfileSuggestionTelephoneNumber

**Schema:** company

A telephone number suggestion for a company profile

```graphql
type CompanyProfileSuggestionTelephoneNumber {
  "Country code of the telephone number (digits only, no leading +)"
  country_code: String
  "Telephone number without the country code (digits only)"
  number: String
}
```

## CompanyProfileSuggestionWebpage

**Schema:** company

A webpage URL suggestion for a company profile

```graphql
type CompanyProfileSuggestionWebpage {
  "Webpage type (e.g. webpage, privacy_policy, terms_and_conditions, other)"
  type: String
  "Full URL to the webpage"
  url: String
}
```

## CompanyProfileSuggestions

**Schema:** company

Company profile suggestions extracted from a website by the AI

```graphql
type CompanyProfileSuggestions {
  "Suggested short description about the company"
  about_us: String
  "Suggested addresses found on the website"
  addresses: [CompanyProfileSuggestionAddress]
  "Suggested emails found on the website"
  emails: [CompanyProfileSuggestionEmail]
  "Suggested legal name"
  legal_name: String
  "Organization type name suggested by the AI (display name, not an ID)"
  organization_type: String
  "Resolved organization type ID for the suggested organization type (nil if no match)"
  organization_type_id: Id
  "Suggested social network URLs found on the website"
  social_networks: [CompanyProfileSuggestionSocialNetwork]
  "Suggested telephone numbers found on the website"
  telephone_numbers: [CompanyProfileSuggestionTelephoneNumber]
  "Vertical type name suggested by the AI (display name, not an ID)"
  vertical_type: String
  "Resolved vertical type ID for the suggested vertical type (nil if no match)"
  vertical_type_id: Id
  "Suggested webpage URLs found on the website (home, about, privacy policy, etc.)"
  webpages: [CompanyProfileSuggestionWebpage]
  "Suggested year the company was founded"
  year_founded: Integer
}
```

## CompanyRcsInformation

**Schema:** company

Persisted RCS agent information for a company

```graphql
type CompanyRcsInformation {
  "Description of the capabilities the agent advertises"
  agent_capabilities: String
  "Primary theme color in HEX format (e.g. #FF0000)"
  agent_color_schema_primary: String
  "Secondary theme color in HEX format (e.g. #00FF00)"
  agent_color_schema_secondary: String
  "Short description of the RCS agent (max 256 characters)"
  agent_description: String
  "URL of the agent logo (uploaded separately via prepareFileUpload)"
  agent_logo_url: String
  "Display name of the RCS agent (max 40 characters)"
  agent_name: String
  "Region the agent operates in"
  agent_region: String
  "Person responsible for authorizing RCS messaging on behalf of the company"
  authorization_contact: RcsAuthorizationContact
  "ISO country code where the company was incorporated"
  country_of_incorporation: String
  "The unique identifier"
  id: Id!
  "When this record was created"
  inserted_at: NaiveDatetime
  "Whether the agent supports rich media like images and video"
  rich_media_support: Boolean
  "Actions a user can trigger during a conversation"
  suggested_actions: [RcsSuggestedAction]
  "Quick replies a user can tap during a conversation"
  suggested_replies: [RcsSuggestedReply]
  "When this record was last updated"
  updated_at: NaiveDatetime
  "Welcome message shown when a user first opens a conversation (max 120 characters)"
  welcome_message: String
}
```

## CompanySettings

**Schema:** company

```graphql
type CompanySettings {
  "About us visibility of the company"
  about_us_visibility: [VisibilityType]
  "B2C relation visibility of the company"
  b2c_visibility: [VisibilityType]
  "Brand name visibility of the company"
  brand_name_visibility: [VisibilityType]
  "The unique identifier of the company"
  id: String!
  "Legal name visibility of the company"
  legal_name_visibility: [VisibilityType]
  "Logo url visibility of the company"
  logo_url_visibility: [VisibilityType]
  "Metadata visibility of the company"
  metadata_visibility: [VisibilityType]
  "Organization type visibility of the company"
  organization_type_visibility: [VisibilityType]
  "A key/value storage for private data"
  secret_storage: Json
  "Specialties visibility of the company"
  specialties_visibility: [VisibilityType]
  "Subscription settings of the company, enabled and disabled channels"
  subscription_settings: CompanySubscriptionSettings
  "Trusted domains of the company"
  trusted_domains: [TrustedDomain]
  "Vertical type visibility of the company"
  vertical_type_visibility: [VisibilityType]
  "Year of foundation visibility of the company"
  year_founded_visibility: [VisibilityType]
}
```

## CompanySubscriptionSettings

**Schema:** user, company

The company subscription settings

```graphql
type CompanySubscriptionSettings {
  "Whether the email channel is enabled for subscriptions or not"
  enable_email: Boolean!
  "Whether the sms channel is enabled for subscriptions or not"
  enable_sms: Boolean!
  "Whether the voice channel is enabled for subscriptions or not"
  enable_voice: Boolean!
}
```

## CompanyTaxId

**Schema:** user, company

A company can have multiple tax IDs, e.g. EIN, Sales Tax, etc.

```graphql
type CompanyTaxId {
  "The unique ID for tax ID"
  id: String!
  "The type of the tax identifier, e.g. EIN, Sales Tax, etc."
  type: CompanyTaxIdType
  "The US state to which the tax ID applies (if relevant), e.g. for Sales Tax IDs"
  us_state: String
  "The Tax Identifier, e.g. the EIN number"
  value: String!
  "The visibility of the tax ID"
  visibility: [CompanyVisibilityType!]
}
```

## CompanyWebhook

**Schema:** company

```graphql
type CompanyWebhook {
  "Whether webhook should be used for B2B connection request received event"
  b2b_connection_request_received_webhook: Boolean!
  "Whether webhook should be used for B2B connection response received event"
  b2b_connection_request_response_webhook: Boolean!
  "Whether webhook should be used for B2B form instance subsmission request received event"
  b2b_form_instance_submission_request_received_webhook: Boolean!
  "Whether webhook should be used for B2C connection request response event"
  b2c_connection_request_response_webhook: Boolean!
  "Whether webhook should be used for B2C subscription request response event"
  b2c_subscription_request_response_webhook: Boolean!
  "Bearer token to be used with the webhook"
  bearer_token: String
  "Whether webhook should be used for C2B connection request received event"
  c2b_connection_request_received_webhook: Boolean!
  "Whether webhook should be used for Company social network status change event"
  company_social_network_status_change_webhook: Boolean!
  "Custom headers to be used with the webhook"
  custom_headers: Json
  "The unique identifier of the company webhook"
  id: Id!
  "Name of the webhook"
  name: String
  "Whether webhook should be used for opt-out event"
  receive_opt_out_events: Boolean!
  "Whether webhook should be used for subscription event"
  receive_subscription_events: Boolean!
  "URL of the webhook"
  url: String!
}
```

## DocsAnswer

**Schema:** user, company

An AI answer to a question about using TNID

```graphql
type DocsAnswer {
  "How to do it through the API, drawn from the documentation. Empty when the question was only about where to go, which `destination` answers on its own."
  answer: String
  "The documentation pages the answer draws on"
  citations: [DocsAnswerCitation]
  "Where to do it in the app: the navigation entry that opens it. Null when the question wasn't about where to go, or nothing supplied fits it."
  destination: DocsAnswerDestination
}
```

## DocsAnswerCitation

**Schema:** user, company

A documentation page cited as a source for an answer

```graphql
type DocsAnswerCitation {
  "Path addressing the page in the published documentation"
  path: String
  "The sections leading to the page, space-joined"
  sections: String
  "The page's title"
  title: String
}
```

## DocsAnswerDestination

**Schema:** user, company

A destination named from the navigation sent with the question

```graphql
type DocsAnswerDestination {
  "The label that navigation entry carries"
  label: String
  "The path it opens, exactly as it was supplied"
  path: String
}
```

## Document

**Schema:** user, company

A file stored in a user's or company's document repository

```graphql
type Document {
  "The file size in bytes"
  byte_size: String
  "The MIME content type of the file"
  content_type: String
  "When the document was moved to the trash"
  deleted_at: NaiveDatetime
  "A short-lived URL to download the file"
  download_url: String
  "The original file name"
  file_name: String
  "The folder holding the document; null means the repository root"
  folder_id: Id
  "The unique identifier of the document"
  id: Id!
  "When the document was added"
  inserted_at: NaiveDatetime
  "How the document entered the repository"
  source: DocumentSource
  "Channel provenance for inbound documents (message id, sender and recipient addresses, archived raw payload location); null for uploads"
  source_ref: Json
  "Where the document stands in the repository"
  status: DocumentStatus
  "A short summary of the document, generated when the document is processed and editable by the owner"
  summary: String
  "Suggested tags awaiting acceptance on the document, ordered by name"
  tag_suggestions: [Tag]
  "Why the last attempt to read the document's contents failed. Null when that attempt succeeded, or when the document has not been processed yet"
  tagging_error: DocumentTaggingError
  "Tags assigned to the document, ordered by name"
  tags: [Tag]
  "When the document was last updated"
  updated_at: NaiveDatetime
  "A short-lived URL to view the file"
  url: String
}
```

## DocumentAnswer

**Schema:** user, company

An AI answer to a question asked over the caller's documents

```graphql
type DocumentAnswer {
  "The answer, grounded in the caller's documents"
  answer: String
  "The documents the answer draws on"
  citations: [DocumentAnswerCitation]
}
```

## DocumentAnswerCitation

**Schema:** user, company

A document cited as a source for a document answer

```graphql
type DocumentAnswerCitation {
  "The cited document's file name"
  file_name: String
  "The cited document's id"
  id: Id
}
```

## DocumentUpload

**Schema:** user, company

Where to send a document upload, and the record it will become

```graphql
type DocumentUpload {
  "Id of the reserved document — pass it to confirmDocumentUpload once the file is uploaded"
  document_id: Id!
  "Form fields that must be sent with the upload, before the file itself. Send every one of them unchanged; they carry the signature and the constraints the upload is accepted under"
  fields: Json!
  "The S3 endpoint to post the file to"
  url: String!
}
```

## Email

**Schema:** user, company

```graphql
type Email {
  email: String
  "The unique identifier of the email"
  id: Id!
  status: VerificationStatus
  types: [EmailType]
  visibility: [VisibilityType]
}
```

## ExternalCommunication

**Schema:** company

An external communication message (SMS, MMS, etc.)

```graphql
type ExternalCommunication {
  "Direction of the communication (inbound/outbound)"
  direction: ExternalCommunicationDirection
  "Address of the party on our side of the conversation (usually a company-owned number)"
  host_address: String
  "The unique identifier"
  id: Id!
  "Message body as received/sent"
  message_body: String
  "Address of the party on the external side (user's number or contact)"
  remote_address: String
  "When the communication occurred"
  timestamp: NaiveDatetime
  "Channel type (SMS, MMS, etc.)"
  type: ExternalCommunicationType
}
```

## FileUpload

**Schema:** user, company

The result of preparing a file upload

```graphql
type FileUpload {
  "The S3 file key — save this value to the record after uploading"
  file_key: String!
  "The presigned S3 URL to PUT the file to directly from the client"
  upload_url: String!
}
```

## Folder

**Schema:** user, company

A folder in a user's or company's document repository

```graphql
type Folder {
  "The unique identifier of the folder"
  id: Id!
  "The folder name; sibling names may repeat"
  name: String
  "The parent folder id; null for a folder at the repository root"
  parent_id: Id
}
```

## FoldersPage

**Schema:** user, company

The owner's folder structure

```graphql
type FoldersPage {
  records: [Folder!]!
}
```

## Form

**Schema:** user, company

A form with versions

```graphql
type Form {
  company_id: Id!
  description: String
  form_versions: [FormVersion]
  id: Id!
  inserted_at: NaiveDatetime!
  intended_for: [FormBuilderFormIntendedFor]
  title: String
  updated_at: NaiveDatetime!
  visibility: [FormBuilderFormVisibility]
}
```

## FormFieldOptionSuggestion

**Schema:** company

A suggested option value for select/radio/checkbox fields

```graphql
type FormFieldOptionSuggestion {
  "Option value shown and submitted"
  value: String
}
```

## FormInstance

**Schema:** user, company

A form instance — tracks submission status and data

```graphql
type FormInstance {
  data: Json
  form_version: FormVersion
  id: Id!
  identifiers: [String]
  inserted_at: NaiveDatetime!
  status: FormBuilderFormInstanceStatus!
  updated_at: NaiveDatetime!
}
```

## FormRequestInfo

**Schema:** user, company

Form info as seen by a submission request receiver — restricted view

```graphql
type FormRequestInfo {
  description: String
  id: Id!
  title: String
}
```

## FormSuggestions

**Schema:** company

Form builder suggestions generated from an uploaded file or URL screenshot

```graphql
type FormSuggestions {
  "Suggested form description"
  description: String
  "Suggested form fields, in order"
  form_version_fields: [FormVersionFieldSuggestion]
  "Suggested form title"
  title: String
}
```

## FormVersion

**Schema:** user, company

A version of a form

```graphql
type FormVersion {
  "Count of form instances (submissions/drafts) tied to this version. Can be used to determine editability — a version can only be edited if it's the latest, unpublished, and has no instances."
  form_instances_count: Integer!
  form_version_fields: [FormVersionField]
  id: Id!
  inserted_at: NaiveDatetime!
  published: Boolean!
  updated_at: NaiveDatetime!
  version: Integer!
}
```

## FormVersionField

**Schema:** user, company

A field in a form version

```graphql
type FormVersionField {
  autofill_key: String
  content: String
  id: Id!
  image_file_key: String
  image_url: String
  key: String!
  label: String
  options: [String]
  order: Integer!
  required: Boolean!
  style: Json
  type: FormBuilderFieldType!
  use_as_identifier: Boolean
}
```

## FormVersionFieldSuggestion

**Schema:** company

A suggested form field

```graphql
type FormVersionFieldSuggestion {
  "Autofill key (maps to a known user/company profile value); null for select/radio/checkbox"
  autofill_key: String
  "Options for select/radio/checkbox fields; null for other types"
  field_options: [FormFieldOptionSuggestion]
  "Field label shown to the user"
  label: String
  "Whether the field is required"
  required: Boolean
  "Field input type"
  type: FormBuilderFieldType
}
```

## Group

**Schema:** user

```graphql
type Group {
  "The unique identifier of the group"
  id: String!
  "The logo of the group"
  logo_url: String
  "Additional metadata"
  metadata: Json
  "Name of the group"
  name: String!
  "A key/value storage for private data"
  secret_storage: Json
  "The visibility settings of the group"
  visibility: [VisibilityType]
}
```

## GroupNotificationSettings

**Schema:** user

Notification settings for a user's membership in a specific group

```graphql
type GroupNotificationSettings {
  "Email when a group join request is received"
  group_user_member_join_request_received_email: Boolean!
  "In-app notification when a group join request is received"
  group_user_member_join_request_received_notification: Boolean!
  "The ID of the group user member record"
  id: Id!
}
```

## GroupUserMember

**Schema:** user

```graphql
type GroupUserMember {
  "The group that the user is a member of"
  group: Group!
  "The unique identifier of the membership"
  id: Id!
  "The role of the user in the group"
  role: GroupRoleType!
}
```

## GroupUserMemberInvite

**Schema:** user

```graphql
type GroupUserMemberInvite {
  "The group that the user received the invite to"
  group: Group
  "The unique identifier of the invite"
  id: String!
  "The time the invite was created"
  inserted_at: NaiveDatetime
  "The user that received the invite"
  invited_user: User
  "The time the invite was responded to"
  responded_at: NaiveDatetime
  "The role of the user in the group"
  role: GroupRoleType!
  "The status of the invite"
  status: GroupInviteStatus!
  "The time the invite was last updated"
  updated_at: NaiveDatetime
  "The user that sent the invite"
  user: User
}
```

## GroupUserMemberJoinRequest

**Schema:** user

```graphql
type GroupUserMemberJoinRequest {
  "The group that the user sent the join request to"
  group: Group
  "The unique identifier of the join request"
  id: String!
  "The time the join request was created"
  inserted_at: NaiveDatetime
  "The time the join request was responded to"
  responded_at: NaiveDatetime
  "The role of the user in the group"
  role: GroupRoleType!
  "The status of the join request"
  status: GroupInviteStatus!
  "The time the join request was last updated"
  updated_at: NaiveDatetime
  "The user that sent the join request"
  user: User
}
```

## GroupUserMemberList

**Schema:** user

```graphql
type GroupUserMemberList {
  "The pagination info - containing info on how to paginate further"
  pagination_info: PaginationInfo!
  "A paginated result of members of a group"
  records: [GroupUserMemberListItem!]!
}
```

## GroupUserMemberListItem

**Schema:** user

```graphql
type GroupUserMemberListItem {
  "The role of the user in the group"
  role: GroupRoleType!
  "The user member"
  user: User!
}
```

## Interest

**Schema:** user, company

```graphql
type Interest {
  "Description of the interest"
  description: String
  "ID of the interest"
  id: String
  "Title of the interest"
  title: String
}
```

## InvitationLink

**Schema:** company

A company-owned invitation link. Share it via `invitation_url` or the QR code fields.

```graphql
type InvitationLink {
  "Whether anonymous (non-registered) users may subscribe via this link"
  allow_anonymous_subscription: Boolean!
  "Whether joining users may form a connection with the company"
  allow_user_connection: Boolean!
  "B2C connection type to create when a user joins via this link"
  b2c_connection_type: B2cConnectionType
  "C2C connection type to create when a user joins via this link"
  c2c_connection_type: C2cConnectionType
  "The unique identifier"
  id: Id!
  "When the link was created"
  inserted_at: NaiveDatetime!
  "Server-generated token the client uses when building the shareable URL"
  invitation_token: String!
  "The shareable URL (the frontend join page for this link)"
  invitation_url: String!
  "User who created the link (optional — company-only links have no inviter)"
  invited_by_user: User
  "Human-readable name for this link (shown internally to the company admins)"
  name: String
  "The shareable URL as an inline SVG QR code data-URI, branded with the company logo"
  qr_code: String
  "The QR code as a download-ready PNG data-URI (carries the company name header and the URL as footer)"
  qr_code_download: String
  "Whether the join flow should prompt for email subscription"
  request_email_subscription: Boolean!
  "Whether the join flow should prompt for SMS subscription"
  request_sms_subscription: Boolean!
  "Whether the join flow should prompt for voice subscription"
  request_voice_subscription: Boolean!
  "When the link was last updated"
  updated_at: NaiveDatetime!
}
```

## InvitationSetupResult

**Schema:** user

The requests materialized for an authenticated invitation recipient

```graphql
type InvitationSetupResult {
  "The company connection request, when one applies and the user isn't already connected"
  b2c_connection_request: B2cConnectionRequest
  "One subscription request per channel the link asks for"
  b2c_subscription_requests: [B2cSubscriptionRequest]
  "The user-to-user connection request, when the link carries a connection type"
  c2c_connection_request: C2cConnectionRequest
}
```

## Notification

**Schema:** user, company

An in-app notification

```graphql
type Notification {
  "Ids a destination needs beyond the subject — a group, a form. Empty for
kinds that need nothing else."
  context: Json
  "The unique identifier of the notification"
  id: Id!
  "The date and time the notification was created"
  inserted_at: NaiveDatetime!
  "What the notification is about. Together with `subjectStatus` and
`context` this is what a client routes from — the API states what
happened and each client decides where that leads."
  kind: NotificationKind
  "The read/unread status of the notification"
  status: NotificationStatus!
  "The record the notification is about"
  subject_id: Id
  "The subject's status when the notification was written. What separates
being asked from being answered: the same record produces both, and they
belong in different places."
  subject_status: String
  "The text content of the notification"
  text: String!
  "The date and time the notification was last updated"
  updated_at: NaiveDatetime!
}
```

## OnboardingStatus

**Schema:** user

Per-step onboarding status for a user, plus a computed `fully_onboarded` flag

```graphql
type OnboardingStatus {
  "Status of the company-registration onboarding step"
  company_registered_step: OnboardingStatusValue!
  "Status of the contact-information onboarding step"
  contact_information_step: OnboardingStatusValue!
  "True when every required step is either completed or skipped"
  fully_onboarded: Boolean!
  "Status of the initial-login onboarding step"
  initial_login_step: OnboardingStatusValue!
  "Status of the interests-information onboarding step"
  interests_information_step: OnboardingStatusValue!
  "Status of the invited-contacts onboarding step"
  invited_contacts_step: OnboardingStatusValue!
  "Status of the personal-information onboarding step"
  personal_information_step: OnboardingStatusValue!
  "Status of the social-network-information onboarding step"
  social_network_information_step: OnboardingStatusValue!
}
```

## OptOutRequest

**Schema:** company

```graphql
type OptOutRequest {
  "The company the opt-out request belongs to"
  company: Company
  "The date and time the opt out request was created"
  created_at: NaiveDatetime
  "Request destination - email, phone number, username or any other identifier where request was sent to"
  destination: String
  "External resource id (if applicable) where opt-out request was received (eg. message id)"
  external_id: String
  "The unique identifier of the opt-out request"
  id: Id
  "Textual part of the entire message in which opt-out is requested"
  message_body: String
  "Additional metadata"
  metadata: Json
  "Request origin - email, phone number, username or any other identifier from where request was sent"
  source: String
  "Status of the request"
  status: OptOutRequestStatus
  "Date and time when the opt-out request was initially received"
  timestamp: NaiveDatetime
  "Type of the request"
  type: OptOutRequestType
  "The date and time the opt out request was last updated"
  updated_at: NaiveDatetime
  "The user the opt-out request belongs to"
  user: User
}
```

## OrganizationType

**Schema:** user, company

```graphql
type OrganizationType {
  "Display name of the organization type"
  display_name: String
  "The unique identifier of the organization type"
  id: String
}
```

## OtpData

**Schema:** user, company

```graphql
type OtpData {
  "When will the otp expire"
  expires_at: NaiveDatetime
  "When can the next otp be requested"
  next_otp_at: NaiveDatetime
  "Status of the otp"
  otp_status: String
  "Remaining otp attempts"
  remaining_otp_attempts: Integer
}
```

## PaginatedAiTaskRuns

**Schema:** user, company

A page of a task's runs

```graphql
type PaginatedAiTaskRuns {
  pagination_info: PaginationInfo
  records: [AiTaskRun!]!
}
```

## PaginatedAiTasks

**Schema:** user, company

A page of AI tasks

```graphql
type PaginatedAiTasks {
  pagination_info: PaginationInfo
  records: [AiTask!]!
}
```

## PaginatedB2bConnectionRequests

**Schema:** company

A cursor-paginated page of B2B connection requests

```graphql
type PaginatedB2bConnectionRequests {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of B2B connection request records"
  records: [B2bConnectionRequest!]!
}
```

## PaginatedB2bConnections

**Schema:** company

Cursor-paginated B2B connections, returned by `paginatedB2bConnections`

```graphql
type PaginatedB2bConnections {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of B2B connection records"
  records: [B2bConnection!]!
}
```

## PaginatedB2bFormSubmissionRequests

**Schema:** company

Paginated B2B form submission requests (page-based)

```graphql
type PaginatedB2bFormSubmissionRequests {
  page: Integer!
  records: [B2bFormSubmissionRequest!]!
  total_records: Integer!
}
```

## PaginatedB2cConnectionRequests

**Schema:** user, company

A cursor-paginated page of B2C connection requests

```graphql
type PaginatedB2cConnectionRequests {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of B2C connection request records"
  records: [B2cConnectionRequest!]!
}
```

## PaginatedB2cConnections

**Schema:** user, company

Cursor-paginated B2C connections, returned by `paginatedB2cConnections`

```graphql
type PaginatedB2cConnections {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of B2C connection records"
  records: [B2cConnection!]!
}
```

## PaginatedB2cFormSubmissionRequests

**Schema:** user

Paginated B2C form submission requests (page-based)

```graphql
type PaginatedB2cFormSubmissionRequests {
  page: Integer!
  records: [B2cFormSubmissionRequest!]!
  total_records: Integer!
}
```

## PaginatedB2cSubscriptionRequests

**Schema:** user, company

A cursor-paginated page of B2C subscription requests

```graphql
type PaginatedB2cSubscriptionRequests {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of B2C subscription request records"
  records: [B2cSubscriptionRequest!]!
}
```

## PaginatedB2cSubscriptions

**Schema:** user, company

```graphql
type PaginatedB2cSubscriptions {
  "The pagination info - containing info on how to paginate further"
  pagination_info: PaginationInfo!
  "A paginated result of B2C subscription records"
  records: [B2cSubscription!]!
}
```

## PaginatedC2bConnectionRequests

**Schema:** user, company

A cursor-paginated page of C2B connection requests

```graphql
type PaginatedC2bConnectionRequests {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of C2B connection request records"
  records: [C2bConnectionRequest!]!
}
```

## PaginatedC2cConnectionRequests

**Schema:** user

A cursor-paginated page of C2C connection requests

```graphql
type PaginatedC2cConnectionRequests {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of C2C connection request records"
  records: [C2cConnectionRequest!]!
}
```

## PaginatedC2cConnections

**Schema:** user

Cursor-paginated C2C connections, returned by `paginatedC2cConnections`

```graphql
type PaginatedC2cConnections {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of C2C connection records"
  records: [C2cConnection!]!
}
```

## PaginatedClientSecrets

**Schema:** company

A cursor-paginated page of client secrets

```graphql
type PaginatedClientSecrets {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of client secret records"
  records: [ClientSecret!]!
}
```

## PaginatedCompanyFormVersions

**Schema:** company

A cursor-paginated page of form versions

```graphql
type PaginatedCompanyFormVersions {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of form version records"
  records: [FormVersion!]!
}
```

## PaginatedDocuments

**Schema:** user, company

A cursor-paginated page of documents

```graphql
type PaginatedDocuments {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of document records"
  records: [Document!]!
}
```

## PaginatedFormSubmissions

**Schema:** company

Paginated form submissions (cursor-based)

```graphql
type PaginatedFormSubmissions {
  pagination_info: PaginationInfo!
  records: [FormInstance!]!
}
```

## PaginatedForms

**Schema:** company

```graphql
type PaginatedForms {
  "The pagination info"
  pagination_info: PaginationInfo!
  "A paginated list of forms"
  records: [Form!]!
}
```

## PaginatedGroupUserMemberInvites

**Schema:** user

A cursor-paginated page of group user member invites

```graphql
type PaginatedGroupUserMemberInvites {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of group user member invite records"
  records: [GroupUserMemberInvite!]!
}
```

## PaginatedGroupUserMemberJoinRequests

**Schema:** user

A cursor-paginated page of group user member join requests

```graphql
type PaginatedGroupUserMemberJoinRequests {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of group user member join request records"
  records: [GroupUserMemberJoinRequest!]!
}
```

## PaginatedGroupUserMembers

**Schema:** user

A cursor-paginated page of group memberships

```graphql
type PaginatedGroupUserMembers {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of group membership records"
  records: [GroupUserMember!]!
}
```

## PaginatedInvitationLinks

**Schema:** company

A cursor-paginated page of invitation links

```graphql
type PaginatedInvitationLinks {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of invitation link records"
  records: [InvitationLink!]!
}
```

## PaginatedNotifications

**Schema:** user, company

```graphql
type PaginatedNotifications {
  "The pagination info - containing info on how to paginate further"
  pagination_info: PaginationInfo!
  "A paginated list of notification records"
  records: [Notification!]!
}
```

## PaginatedReceivedB2bFormSubmissionRequests

**Schema:** company

Paginated received B2B form submission requests (cursor-based)

```graphql
type PaginatedReceivedB2bFormSubmissionRequests {
  pagination_info: PaginationInfo!
  records: [B2bFormSubmissionRequest!]!
}
```

## PaginatedReceivedB2cFormSubmissionRequests

**Schema:** user

Paginated received B2C form submission requests (cursor-based)

```graphql
type PaginatedReceivedB2cFormSubmissionRequests {
  pagination_info: PaginationInfo!
  records: [B2cFormSubmissionRequest!]!
}
```

## PaginatedSentB2bFormSubmissionRequests

**Schema:** company

Paginated sent B2B form submission requests (cursor-based)

```graphql
type PaginatedSentB2bFormSubmissionRequests {
  pagination_info: PaginationInfo!
  records: [B2bFormSubmissionRequest!]!
}
```

## PaginatedSentB2cFormSubmissionRequests

**Schema:** company

Paginated sent B2C form submission requests (cursor-based)

```graphql
type PaginatedSentB2cFormSubmissionRequests {
  pagination_info: PaginationInfo!
  records: [B2cFormSubmissionRequest!]!
}
```

## PaginatedSentimentAnalysisReports

**Schema:** company

Paginated sentiment analysis results (page-based)

```graphql
type PaginatedSentimentAnalysisReports {
  "Current page number (1-based)"
  page: Integer!
  "Report records for the current page"
  records: [SentimentAnalysisReport!]!
  "Total records across all pages"
  total_records: Integer!
}
```

## PaginatedSentimentAnalysisResults

**Schema:** company

Paginated sentiment analysis results (cursor-based)

```graphql
type PaginatedSentimentAnalysisResults {
  pagination_info: PaginationInfo!
  records: [SentimentAnalysisReport!]!
}
```

## PaginatedSpamReports

**Schema:** user

A cursor-paginated page of spam reports

```graphql
type PaginatedSpamReports {
  "The pagination info — pass `next_cursor` back as `cursor` to fetch the following page"
  pagination_info: PaginationInfo!
  "A page of spam report records"
  records: [SpamReport!]!
}
```

## PaginatedTenDlcBrands

**Schema:** company

```graphql
type PaginatedTenDlcBrands {
  "The current page number, starts with 1"
  page: Integer!
  "A paginated result of 10DLC brand records"
  records: [TenDlcBrand!]!
  "The total number of records available"
  total_records: Integer!
}
```

## PaginatedTenDlcCampaigns

**Schema:** company

```graphql
type PaginatedTenDlcCampaigns {
  "The current page number, starts with 1"
  page: Integer!
  "A paginated result of 10DLC campaign records"
  records: [TenDlcCampaign!]!
  "The total number of records available"
  total_records: Integer!
}
```

## PaginatedUserImports

**Schema:** company

```graphql
type PaginatedUserImports {
  "The pagination info - containing info on how to paginate further"
  pagination_info: PaginationInfo!
  "A paginated list of user import records"
  records: [UserImport!]!
}
```

## PaginationInfo

**Schema:** user, company

Pagination info

```graphql
type PaginationInfo {
  "Limit on the number of results per query"
  limit: Integer
  "Cursor for the next batch of results, pass to the next query"
  next_cursor: String
}
```

## RcsAuthorizationContact

**Schema:** company

Contact person authorized for RCS messaging

```graphql
type RcsAuthorizationContact {
  "Email addresses associated with the contact"
  emails: [String]
  first_name: String
  last_name: String
  "Telephone numbers associated with the contact"
  telephone_numbers: [String]
  "Title or role (e.g. CEO)"
  title: String
}
```

## RcsInformationSuggestions

**Schema:** company

RCS agent information suggestions generated from the company's existing data

```graphql
type RcsInformationSuggestions {
  "Suggested agent capabilities"
  agent_capabilities: String
  "Suggested primary color in HEX format (e.g. #FF0000)"
  agent_color_schema_primary: String
  "Suggested secondary color in HEX format (e.g. #00FF00)"
  agent_color_schema_secondary: String
  "Suggested RCS agent description (max 256 characters)"
  agent_description: String
  "Suggested RCS agent name (max 40 characters)"
  agent_name: String
  "Suggested region the agent will operate in"
  agent_region: String
  "ISO country code where the company was incorporated"
  country_of_incorporation: String
  "Whether the agent should advertise rich-media support"
  rich_media_support: Boolean
  "Suggested actions a user can trigger during a conversation"
  suggested_actions: [RcsSuggestionItem]
  "Suggested quick replies a user can tap during a conversation"
  suggested_replies: [RcsSuggestionItem]
  "Suggested welcome message shown when a user opens a conversation"
  welcome_message: String
}
```

## RcsSuggestedAction

**Schema:** company

A persisted suggested action for RCS messaging

```graphql
type RcsSuggestedAction {
  "The unique identifier"
  id: Id!
  "Display text for the action"
  name: String!
}
```

## RcsSuggestedReply

**Schema:** company

A persisted suggested reply for RCS messaging

```graphql
type RcsSuggestedReply {
  "The unique identifier"
  id: Id!
  "Display text for the reply"
  name: String!
}
```

## RcsSuggestionItem

**Schema:** company

A suggested RCS reply or action (name-only, no ID since it is not persisted yet)

```graphql
type RcsSuggestionItem {
  "Display text for the reply/action"
  name: String
}
```

## SearchResult

**Schema:** user, company

A single global-search row. The same shape is used for users, companies, and groups; fields that do not apply to a given kind are returned empty.

```graphql
type SearchResult {
  "Addresses visible to the viewer; only returned when the caller requests sensitive data"
  addresses: [SearchResultAddress!]
  "Contact emails visible to the viewer; only returned when the caller requests sensitive data"
  emails: [SearchResultEmail!]
  "The unique identifier of the entity"
  id: Id!
  "Avatar or logo URL; may be nil when visibility hides the image from the viewer"
  image: String
  "Display name of the entity"
  label: String!
  "The viewer's relationship to this entity (connection types, group role, etc.); empty when the viewer has no relationship"
  relation: [String!]
  "Contact phone numbers visible to the viewer; only returned when the caller requests sensitive data"
  telephone_numbers: [SearchResultTelephoneNumber!]
  "Which kind of entity this row represents"
  type: SearchResultType!
  "Username; populated only for entities of type user"
  username: String
}
```

## SearchResultAddress

**Schema:** user, company

```graphql
type SearchResultAddress {
  city: String
  country: String
  id: Id!
  state: String
  street: String
  visibility: [String!]
  zip_code: String
}
```

## SearchResultEmail

**Schema:** user, company

```graphql
type SearchResultEmail {
  email: String
  id: Id!
  visibility: [String!]
}
```

## SearchResultTelephoneNumber

**Schema:** user, company

```graphql
type SearchResultTelephoneNumber {
  id: Id!
  number: String
  visibility: [String!]
}
```

## SentimentAnalysisReport

**Schema:** company

A sentiment analysis report for an external communication

```graphql
type SentimentAnalysisReport {
  "Recommended action based on the message's sentiment"
  action: SentimentAnalysisAction!
  "Confidence score the AI assigns to its recommended action (0.0–1.0)"
  certainty_factor: Float!
  "The external communication this report analyzes"
  external_communication: ExternalCommunication
  "The unique identifier"
  id: Id!
  "When the report was created"
  inserted_at: NaiveDatetime!
  "Related communications exchanged with the same address pair near the analyzed message, ordered most-recent first"
  thread: [ExternalCommunication!]!
  "Detected topics or intent tags"
  topics: [String]
  "When the report was last updated"
  updated_at: NaiveDatetime!
}
```

## ShallowCompany

**Schema:** user, company

Shallow Company object

```graphql
type ShallowCompany {
  "The brand name of the company"
  brand_name: String
  "The unique identifier of the company"
  id: String!
  "The legal name of the company"
  legal_name: String
  "The TnID profile name of the company"
  profile_name: String
}
```

## SmsOptInQrCode

**Schema:** company

```graphql
type SmsOptInQrCode {
  message: String
  "Inline SVG data-URI for on-screen preview"
  qr_code: String
  "Download-ready PNG data-URI (carries the company name header + rates disclaimer)"
  qr_code_download: String
  telephone_number: TelephoneNumber
}
```

## SpamReport

**Schema:** user

```graphql
type SpamReport {
  "The channel type of the spam report"
  channel_type: SpamReportChannelType
  "The date and time the spam report was created"
  created_at: NaiveDatetime
  "Free-form description of the incident provided when the report was filed"
  description: String
  "The destination that the content of the report arrived to"
  destination: String
  from_number: String
  "The unique identifier of the Spam Report"
  id: Id
  "The issue type of the spam report"
  issue_type: SpamReportIssueType
  "If the report is about an SMS the content of the SMS"
  message_content: String
  "Additional metadata"
  metadata: Json
  "The date and time the the spam report happened"
  reported_at: NaiveDatetime
  "The source that the content of the report arrived from"
  source: String
  "Current status of the spam report"
  status: SpamReportStatus
  timestamp: NaiveDatetime
  to_number: String
  "The date and time the spam report was last updated"
  updated_at: NaiveDatetime
  "User reporting the incident."
  user: User
  "Additional note from the user"
  user_note: String
}
```

## Specialty

**Schema:** user, company

```graphql
type Specialty {
  "Description of the specialty"
  description: String
  "ID of the specialty"
  id: String
  "Title of the specialty"
  title: String
}
```

## StatusResponse

**Schema:** user, company

Generic response containing just a success/failure status — used by mutations that don't need to return a domain object

```graphql
type StatusResponse {
  "Status of the request"
  status: ResponseStatus
}
```

## Tag

**Schema:** user, company

A tag in a user's or company's document repository

```graphql
type Tag {
  "The unique identifier of the tag"
  id: Id!
  "When the tag was created"
  inserted_at: NaiveDatetime
  "The tag name"
  name: String!
  "When the tag was last updated"
  updated_at: NaiveDatetime
}
```

## TelephoneNumber

**Schema:** user, company

```graphql
type TelephoneNumber {
  "The unique identifier of the telephone number"
  id: Id!
  number: String
  status: VerificationStatus
  types: [TelephoneNumberType]
  visibility: [VisibilityType]
}
```

## TenDlcApiKey

**Schema:** company

```graphql
type TenDlcApiKey {
  "Unique 10DLC API Key identifier"
  api_key_id: String!
  "Unique 10DLC API Key secret"
  api_key_secret: String!
  "Type of the API key (owned or authorized)"
  api_key_type: TenDlcApiKeyType!
  "The company that owns the API key"
  company: ShallowCompany
  "Which company the API key belongs to"
  company_id: String!
  "Unique internal API Key identifier"
  id: Id!
  "Record insertion timestamp"
  inserted_at: NaiveDatetime
  "API Key name / label"
  name: String
  "Record update timestamp"
  updated_at: NaiveDatetime
}
```

## TenDlcApiKeyAuthorization

**Schema:** company

```graphql
type TenDlcApiKeyAuthorization {
  "10DLC API Key"
  api_key: TenDlcApiKey!
  "When the API key was shared with the current company"
  authorized_at: NaiveDatetime
  "The authorized company (shallow means only the basic fields are included)"
  company: ShallowCompany!
  "Authorization record identifier"
  id: Id!
}
```

## TenDlcBrand

**Schema:** company

```graphql
type TenDlcBrand {
  "Alternative business ID"
  alt_business_id: String
  "Alternative business ID type"
  alt_business_id_type: String
  "TCR Brand ID (e.g., B123456, null for drafts)"
  brand_id: String
  "Relationship to brand"
  brand_relationship: String
  "Business contact email"
  business_contact_email: String
  "City"
  city: String
  "Link to local company"
  company_id: String!
  "Company legal name"
  company_name: String
  "Country code"
  country: String
  "Creation date"
  create_date: String
  "CSP identifier"
  csp_id: String
  "Brand display name"
  display_name: String
  "Employer identification number"
  ein: String
  "EIN issuing country"
  ein_issuing_country: String
  "Contact email"
  email: String
  "Business entity type"
  entity_type: TenDlcEntityType
  "Contact first name (for sole proprietors)"
  first_name: String
  "Internal identifier (UUID)"
  id: String!
  "Brand identity verification status"
  identity_status: String
  "Record insertion timestamp"
  inserted_at: NaiveDatetime
  "Contact last name (for sole proprietors)"
  last_name: String
  "Mobile phone number"
  mobile_phone: String
  "Test/mock brand flag"
  mock: Boolean
  "Additional custom attributes"
  optional_attributes: Json
  "Ownership type to brand, "DIRECT" or "PARTNER""
  ownership_type: TenDlcOwnershipType
  "Contact phone number"
  phone: String
  "Postal code"
  postal_code: String
  "External reference ID"
  reference_id: String
  "State"
  state: String
  "Brand status"
  status: TenDlcBrandStatus
  "Stock exchange"
  stock_exchange: String
  "Stock ticker symbol"
  stock_symbol: String
  "Street address"
  street: String
  "Last sync timestamp"
  synced_at: NaiveDatetime
  "10DLC API key used to register this brand"
  ten_dlc_api_key_id: String
  "Record update timestamp"
  updated_at: NaiveDatetime
  "Industry vertical"
  vertical: String
  "Brand website"
  website: String
  "Workflow status"
  workflow_status: TenDlcBrandWorkflowStatus
}
```

## TenDlcCampaign

**Schema:** company

```graphql
type TenDlcCampaign {
  "Age-gated content"
  age_gated: Boolean
  "Auto-renewal enabled"
  auto_renewal: Boolean
  "Billing date"
  billed_date: NaiveDatetime
  "TCR Brand ID (e.g., B123456, null for draft brands)"
  brand_id: String
  "TCR Campaign ID (e.g., C123456, null for drafts)"
  campaign_id: String
  "Link to local company"
  company_id: String!
  "Creation date"
  create_date: NaiveDatetime
  "CSP identifier"
  csp_id: String
  "Campaign description"
  description: String
  "Direct lending content"
  direct_lending: Boolean
  "Contains embedded links"
  embedded_link: Boolean
  "Sample embedded link"
  embedded_link_sample: String
  "Contains embedded phone numbers"
  embedded_phone: Boolean
  "Expiration date"
  expiration_date: NaiveDatetime
  "Keywords for help"
  help_keywords: String
  "Help response message"
  help_message: String
  "Internal identifier (UUID)"
  id: String!
  "Record insertion timestamp"
  inserted_at: NaiveDatetime
  "Internal brand identifier (UUID)"
  internal_brand_id: String!
  "Message flow description"
  message_flow: String
  "MNO-specific metadata"
  mno_metadata: Json
  "Test/mock campaign flag"
  mock: Boolean
  "Next renewal/expiration date"
  next_renewal_or_expiration_date: Date
  "Uses number pooling"
  number_pool: Boolean
  "Keywords for opt-in"
  optin_keywords: String
  "Opt-in confirmation message"
  optin_message: String
  "Keywords for opt-out"
  optout_keywords: String
  "Opt-out confirmation message"
  optout_message: String
  "Ownership type to campaign, "DIRECT" or "PARTNER""
  ownership_type: TenDlcOwnershipType
  "Privacy policy URL"
  privacy_policy_link: String
  "External reference ID"
  reference_id: String
  "Reseller identifier"
  reseller_id: String
  "Message sample 1"
  sample1: String
  "Message sample 2"
  sample2: String
  "Message sample 3"
  sample3: String
  "Message sample 4"
  sample4: String
  "Message sample 5"
  sample5: String
  "Campaign status"
  status: TenDlcCampaignStatus
  "Sub-use cases"
  sub_usecases: [String]
  "Has help mechanism"
  subscriber_help: Boolean
  "Requires opt-in"
  subscriber_optin: Boolean
  "Has opt-out mechanism"
  subscriber_optout: Boolean
  "Last sync timestamp"
  synced_at: NaiveDatetime
  "Requires T&C acceptance"
  terms_and_conditions: Boolean
  "Terms and conditions URL"
  terms_and_conditions_link: String
  "Record update timestamp"
  updated_at: NaiveDatetime
  "Primary use case"
  usecase: String
  "Industry vertical"
  vertical: String
  "Workflow status"
  workflow_status: TenDlcCampaignWorkflowStatus
}
```

## TenDlcCampaignWithTelephoneNumbers

**Schema:** company

```graphql
type TenDlcCampaignWithTelephoneNumbers {
  "The campaign"
  campaign: TenDlcCampaign
  "Associated telephone numbers"
  telephone_numbers: [TenDlcComplianceTelephoneNumber]
}
```

## TenDlcComplianceTelephoneNumber

**Schema:** company

```graphql
type TenDlcComplianceTelephoneNumber {
  "TCR Campaign ID (e.g., C123456)"
  campaign_id: String
  "Current OSR campaign ID"
  current_osr_campaign_id: String
  "Current OSR NNID"
  current_osr_nnid: String
  "Current T-Mobile campaign ID"
  current_tmobile_campaign_id: String
  "Current T-Mobile NNID"
  current_tmobile_nnid: String
  "Telephone number record ID"
  id: String!
  "Record insertion timestamp"
  inserted_at: NaiveDatetime
  "Internal campaign identifier (UUID)"
  internal_campaign_id: String
  "Full telephone number"
  number: String!
  "OSR submission error details"
  osr_error: Json
  "OSR workflow status"
  osr_workflow_status: TenDlcComplianceTelephoneNumberStatus
  "Requested NNID"
  requested_nnid: String
  "Requested OSR campaign ID"
  requested_osr_campaign_id: String
  "Requested T-Mobile campaign ID"
  requested_tmobile_campaign_id: String
  "T-Mobile submission error details"
  tmobile_error: Json
  "T-Mobile workflow status"
  tmobile_workflow_status: TenDlcComplianceTelephoneNumberStatus
  "Record update timestamp"
  updated_at: NaiveDatetime
}
```

## TrustedDomain

**Schema:** user, company

Trusted domain

```graphql
type TrustedDomain {
  domain: String!
  "The unique identifier of the trusted domain"
  id: Id!
}
```

## User

**Schema:** user, company

```graphql
type User {
  "The about me of the user"
  about_me: String
  "About me visibility of the user"
  about_me_visibility: [VisibilityType]
  "The addresses of the user"
  addresses: [Address]
  "The birthdate of the user"
  birthdate: Date
  "Birthdate visibility of the user"
  birthdate_visibility: [VisibilityType]
  "The viewer's connection state to this user (drives the profile-view actions area)"
  connection: ViewerConnection
  "The maximum total bytes the user's document repository may occupy; only the user themselves can read it (string — see above)"
  document_repository_byte_limit: String
  "The dedicated email address that files can be sent to for this user's document repository"
  document_repository_email_address: String
  "The phone number that files can be texted (SMS/MMS) to for the document repository (digits only, no leading +)"
  document_repository_phone_number: String
  "Total bytes the user's documents currently occupy, trash included; only the user themselves can read it (string — a byte count can exceed a 32-bit integer)"
  document_repository_used_bytes: String
  "The emails of the user"
  emails: [UserEmail]
  "The first name of the user"
  first_name: String
  "The unique identifier of the user"
  id: String
  "The interests of the user"
  interests: [Interest]
  "Interests visibility of the user"
  interests_visibility: [VisibilityType]
  "The last name of the user"
  last_name: String
  "Additional metadata"
  metadata: Json
  "Metadata visibility of the user"
  metadata_visibility: [VisibilityType]
  "The middle name of the user"
  middle_name: String
  "Name visibility of the user"
  name_visibility: [VisibilityType]
  "The profile image of the company"
  profile_image_url: String
  "Profile image url visibility of the user"
  profile_image_url_visibility: [VisibilityType]
  "A key/value storage for private data"
  secret_storage: Json
  "The social networks of the user"
  social_networks: [Webpage]
  "The telephone numbers of the user"
  telephone_numbers: [UserTelephoneNumber]
  "The timezone of the user"
  timezone: String
  "Timezone visibility of the user"
  timezone_visibility: [VisibilityType]
  "The username of the user"
  username: String!
  "The webpages of the user"
  webpages: [Webpage]
}
```

## UserDashboardStats

**Schema:** user

Aggregated dashboard statistics for a user

```graphql
type UserDashboardStats {
  "Total number of established company connections"
  b2c_connections_count: Integer!
  "Total number of established people connections"
  c2c_connections_count: Integer!
  "Number of companies the user has a privileged role in"
  companies_count: Integer!
  "Number of pending received company connection requests"
  pending_b2c_connection_requests_count: Integer!
  "Number of pending received people connection requests"
  pending_c2c_connection_requests_count: Integer!
}
```

## UserEmail

**Schema:** user, company

```graphql
type UserEmail {
  email: String
  "The unique identifier of the email"
  id: Id!
  primary: Boolean
  status: VerificationStatus
  types: [EmailType]
  visibility: [VisibilityType]
}
```

## UserImport

**Schema:** company

A company user import record

```graphql
type UserImport {
  "Signed URL to download the error report CSV, present only when status is error"
  error_file_url: String
  "The S3 file key of the uploaded CSV"
  file_name: String!
  "The unique identifier of the import"
  id: Id!
  "The date and time the import was created"
  inserted_at: NaiveDatetime!
  "Internal note about the import"
  note: String
  "The current status of the import"
  status: UserImportStatus!
  "The date and time the import was last updated"
  updated_at: NaiveDatetime!
}
```

## UserNotificationSettings

**Schema:** user

Personal notification settings for a user

```graphql
type UserNotificationSettings {
  "Email when a company connection request is received"
  b2c_conn_request_received_email: Boolean!
  "In-app notification when a company connection request is received"
  b2c_conn_request_received_notification: Boolean!
  "Email when a company form submission request is received"
  b2c_form_instance_request_received_email: Boolean!
  "In-app notification when a company form submission request is received"
  b2c_form_instance_request_received_notification: Boolean!
  "Email when a company subscription request is received"
  b2c_sub_request_received_email: Boolean!
  "In-app notification when a company subscription request is received"
  b2c_sub_request_received_notification: Boolean!
  "Email when a company connection request response is received"
  c2b_conn_request_response_email: Boolean!
  "In-app notification when a company connection request response is received"
  c2b_conn_request_response_notification: Boolean!
  "Email when a people connection request is received"
  c2c_conn_request_received_email: Boolean!
  "In-app notification when a people connection request is received"
  c2c_conn_request_received_notification: Boolean!
  "Email when a people connection request response is received"
  c2c_conn_request_response_email: Boolean!
  "In-app notification when a people connection request response is received"
  c2c_conn_request_response_notification: Boolean!
}
```

## UserPendingActionCounts

**Schema:** user

Counts of items awaiting the current user's response

```graphql
type UserPendingActionCounts {
  "Company connection requests received and not yet answered"
  company_connection_requests: Integer!
  "Form submission requests waiting on this user: those not yet started, and
those returned with changes requested. Requests already submitted, settled
or in progress are excluded."
  form_requests: Integer!
  "Group invites received and not yet answered"
  group_invites: Integer!
  "Documents received over a message channel and awaiting confirmation"
  pending_documents: Integer!
  "People connection requests received and not yet answered"
  people_connection_requests: Integer!
  "Subscription requests received and not yet answered"
  subscription_requests: Integer!
}
```

## UserSettings

**Schema:** user

```graphql
type UserSettings {
  "About me visibility of the user"
  about_me_visibility: [VisibilityType]
  "Birthdate visibility of the user"
  birthdate_visibility: [VisibilityType]
  "The unique identifier of the user"
  id: String
  "Interests visibility of the user"
  interests_visibility: [VisibilityType]
  "Metadata visibility of the user"
  metadata_visibility: [VisibilityType]
  "Name visibility of the user"
  name_visibility: [VisibilityType]
  "Profile image url visibility of the user"
  profile_image_url_visibility: [VisibilityType]
  "A key/value storage for private data"
  secret_storage: Json
  "Timezone visibility of the user"
  timezone_visibility: [VisibilityType]
}
```

## UserTelephoneNumber

**Schema:** user, company

```graphql
type UserTelephoneNumber {
  "The unique identifier of the telephone number"
  id: Id!
  number: String
  primary: Boolean
  status: VerificationStatus
  types: [TelephoneNumberType]
  visibility: [VisibilityType]
}
```

## VerticalType

**Schema:** user, company

```graphql
type VerticalType {
  "The description of the vertical type"
  description: String
  "The name of the vertical type"
  display_name: String!
  "The unique identifier of the vertical type"
  id: String
}
```

## ViewerConnection

**Schema:** user, company

Connection state between the viewer and the viewed user/company

```graphql
type ViewerConnection {
  "Id of the established connection — present when status is CONNECTED (used to remove it)"
  connection_id: Id
  "Connection / request type (e.g. FRIEND, CUSTOMER, PARTNER); null when NONE/SELF"
  connection_type: ViewerConnectionType
  "Id of the pending request — present when status is PENDING_* (used to respond/revoke)"
  request_id: Id
  "Relationship state from the viewer's perspective"
  status: ViewerConnectionStatus!
}
```

## Webpage

**Schema:** user, company

```graphql
type Webpage {
  "The unique identifier of the webpage"
  id: Id!
  "Type of the webpage"
  type: WebpageType
  "URL of the webpage"
  url: String
  "Current verification status of the URL based on automated reachability checks"
  url_verification_status: UrlVerificationStatus
  visibility: [VisibilityType]
}
```