> ## Documentation Index
> Fetch the complete documentation index at: https://docs.conduit.financial/llms.txt
> Use this file to discover all available pages before exploring further.

# Discover onboarding requirements for a country

> Returns `fields[]`, `documents[]`, and `individualRequirements[]` for the given `country` (alpha-2 or alpha-3, normalized server-side; response always echoes alpha-3). `documents[]` is a checklist of what to collect; the integrator uploads each via `POST /v2/documents` (file only) and references the returned ids at submit time.



## OpenAPI

````yaml https://api.sandbox.conduit.financial/v2/api-docs/openapi.json get /onboarding/requirements
openapi: 3.0.0
info:
  title: Conduit Sandbox API
  description: >-
    **Sandbox API** — clients integrate against this surface to exercise happy
    and unhappy paths without consuming real KYC/PSP credits or moving real
    money. Customer KYC, banking partners, and crypto custody are stubbed;
    org-level KYB runs against real providers. Simulation endpoints under
    `/v2/sandbox/*` drive specific scenarios.


    Internal and portal endpoints are excluded from this spec.
  version: '2.0'
  contact: {}
servers:
  - url: https://api.sandbox.conduit.financial/v2
    description: Sandbox
  - url: https://api.conduit.financial/v2
    description: Production
security:
  - api-key: []
tags:
  - name: Customers
  - name: Registered Addresses
  - name: Wallets
  - name: Wallet Signers
  - name: Signing Quorum
  - name: Virtual Accounts
  - name: Applications
  - name: RFIs
  - name: Documents
  - name: Verifications
  - name: Signing Requests
  - name: Transactions
  - name: Payouts
  - name: Whitelist Recipients
  - name: Orders
  - name: Asset Chain Pairs
  - name: Quotes
  - name: Webhook Endpoints
  - name: Webhook Deliveries
  - name: Webhook Event Types
  - name: Features
  - name: Customer Onboarding
  - name: Markup
  - name: Sandbox
paths:
  /onboarding/requirements:
    get:
      tags:
        - Customer Onboarding
      summary: Discover onboarding requirements for a country
      description: >-
        Returns `fields[]`, `documents[]`, and `individualRequirements[]` for
        the given `country` (alpha-2 or alpha-3, normalized server-side;
        response always echoes alpha-3). `documents[]` is a checklist of what to
        collect; the integrator uploads each via `POST /v2/documents` (file
        only) and references the returned ids at submit time.
      operationId: OnboardingController_resolveDiscovery_v2
      parameters:
        - name: country
          required: true
          in: query
          description: >-
            ISO 3166-1 alpha-2 or alpha-3 country code for the customer's
            primary jurisdiction. For an individual subject this is the account
            holder's country of residence.
          schema:
            type: string
        - name: subjectType
          required: false
          in: query
          description: >-
            The application subject. `business` (the default when omitted)
            onboards an entity; `individual` onboards a natural person, whose
            data goes under `ownership.persons[0]` and `activity`.
          schema:
            type: string
            enum:
              - business
              - individual
        - name: industry
          required: false
          in: query
          description: >-
            The `key` of a `GET /v2/onboarding/policy-subjects?axis=industry`
            entry, submitted at `companyClassification.primaryIndustry`. Adds
            any fields, documents and person requirements tied to that industry
            to the returned `fields[]`, `documents[]`, and
            `individualRequirements[]`. Omit to get the industry-agnostic
            response. A business subject only: an individual carries no company
            classification, so passing it with `subjectType=individual` is
            rejected.
          schema:
            type: string
        - name: nationality
          required: false
          in: query
          description: >-
            ISO 3166-1 alpha-2 or alpha-3 country code for the account holder's
            nationality. Omit it to get the response for an account holder whose
            nationality is unknown: the identifier fields then follow the
            country of residence alone. An individual subject only: a business
            carries no nationality, so passing it with `subjectType=business` is
            rejected.
          schema:
            type: string
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ExternalRequirementsResponseDto'
        '400':
          description: >-
            **INVALID_OID_FORMAT**: A path or query parameter expected a valid
            object identifier but received a value that does not match the
            expected format.


            **VALIDATION_ERROR**: The request body or query parameters failed
            validation. One or more fields have invalid values, missing required
            properties, or incorrect types. A required text field that holds
            only spaces counts as missing. Multipart file uploads that fail at
            the multipart-parser layer (unexpected form-field name, too many
            parts) carry an extra 'field' member naming the offending
            form-field.


            **INVALID_POLICY_SUBJECT**: The submitted catalog-backed
            classification key (e.g. `companyClassification.primaryIndustry`) is
            unknown, retired, not directly selectable, or does not match the
            field's expected subject kind. Valid options are surfaced by the
            discovery endpoint.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationErrorDto'
              example:
                type: INVALID_OID_FORMAT
                title: Invalid Object ID Format
                status: 400
                detail: >-
                  A path or query parameter expected a valid object identifier
                  but received a value that does not match the expected format.
                resolution: >-
                  Verify that all IDs in the request URL and query parameters
                  are correctly formatted. IDs are typically prefixed strings
                  like 'cus_...', 'app_...', or 'doc_...'.
                docs: https://conduit-v2.mintlify.app/errors#invalid-oid-format
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
        '401':
          description: >-
            **API_KEY_MISSING**: The request did not include an API key. All API
            requests must be authenticated.


            **API_KEY_INVALID**: The provided API key is not recognized or has
            been revoked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetailDto'
              example:
                type: API_KEY_MISSING
                title: API Key Missing
                status: 401
                detail: >-
                  The request did not include an API key. All API requests must
                  be authenticated.
                resolution: >-
                  Include your API key in the 'x-api-key' header with every
                  request.
                docs: https://conduit-v2.mintlify.app/errors#api-key-missing
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
        '403':
          description: >-
            **ORGANIZATION_ACCESS_SUSPENDED**: Conduit has suspended this
            organization's access. Requests with the organization's API keys and
            from its users are refused until Conduit restores access.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetailDto'
              example:
                type: ORGANIZATION_ACCESS_SUSPENDED
                title: Organization Access Suspended
                status: 403
                detail: >-
                  Conduit has suspended this organization's access. Requests
                  with the organization's API keys and from its users are
                  refused until Conduit restores access.
                resolution: Contact Conduit support.
                docs: >-
                  https://conduit-v2.mintlify.app/errors#organization-access-suspended
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
        '404':
          description: >-
            **NOT_FOUND**: The requested resource does not exist or you do not
            have access to it.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetailDto'
              example:
                type: NOT_FOUND
                title: Not Found
                status: 404
                detail: >-
                  The requested resource does not exist or you do not have
                  access to it.
                resolution: >-
                  Check that the resource ID in the URL is correct. The resource
                  may have been deleted or may belong to a different account.
                docs: https://conduit-v2.mintlify.app/errors#not-found
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
        '422':
          description: >-
            **SUBJECT_REQUIREMENTS_NOT_AVAILABLE**: No requirements are
            available for the requested subject type in the current context —
            the country, provider, and organization conditions of the request —
            so it cannot be fulfilled. This does not assert that no requirements
            exist for the subject anywhere; it reports that none apply to this
            request. It is returned wherever a subject's requirements are read:
            onboarding discovery and submit, and feature-request discovery and
            submit. It is a deterministic state, not a transient outage: it does
            not resolve on retry.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetailDto'
              example:
                type: SUBJECT_REQUIREMENTS_NOT_AVAILABLE
                title: Subject Requirements Not Available
                status: 422
                detail: >-
                  No requirements are available for the requested subject type
                  in the current context — the country, provider, and
                  organization conditions of the request — so it cannot be
                  fulfilled. This does not assert that no requirements exist for
                  the subject anywhere; it reports that none apply to this
                  request. It is returned wherever a subject's requirements are
                  read: onboarding discovery and submit, and feature-request
                  discovery and submit. It is a deterministic state, not a
                  transient outage: it does not resolve on retry.
                resolution: >-
                  This subject type is not available for your organization in
                  this context at this time. Do not retry. Contact your Conduit
                  account manager.
                docs: >-
                  https://conduit-v2.mintlify.app/errors#subject-requirements-not-available
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
        '429':
          description: >-
            **RATE_LIMITED**: Too many requests. This error is returned by three
            independent checks: the per-organization bucket applied to every
            authenticated API request; the per-IP bucket applied to
            unauthenticated traffic before an API key is validated; and the
            per-IP bucket applied when repeated invalid API keys are submitted
            from the same address. Honor the Retry-After header (also exposed as
            retryAfterSeconds in the body) before retrying. Current limits and
            remaining budget are visible in X-RateLimit-Limit (the bucket size),
            X-RateLimit-Remaining, and X-RateLimit-Reset (seconds until the
            bucket refills) on every response once your API key is accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RateLimitedErrorDto'
              example:
                type: RATE_LIMITED
                title: Rate Limited
                status: 429
                detail: >-
                  Too many requests. This error is returned by three independent
                  checks: the per-organization bucket applied to every
                  authenticated API request; the per-IP bucket applied to
                  unauthenticated traffic before an API key is validated; and
                  the per-IP bucket applied when repeated invalid API keys are
                  submitted from the same address. Honor the Retry-After header
                  (also exposed as retryAfterSeconds in the body) before
                  retrying. Current limits and remaining budget are visible in
                  X-RateLimit-Limit (the bucket size), X-RateLimit-Remaining,
                  and X-RateLimit-Reset (seconds until the bucket refills) on
                  every response once your API key is accepted.
                resolution: >-
                  Sleep until Retry-After seconds have elapsed, then retry. For
                  sustained workloads exceeding the per-organization defaults,
                  request a rate-limit increase through your support contact.
                docs: https://conduit-v2.mintlify.app/errors#rate-limited
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
                retryAfterSeconds: 3
        '500':
          description: >-
            **INTERNAL_ERROR**: An unexpected error occurred while processing
            your request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetailDto'
              example:
                type: INTERNAL_ERROR
                title: Internal Error
                status: 500
                detail: An unexpected error occurred while processing your request.
                resolution: >-
                  Retry the request after a brief delay. If the error persists,
                  contact support and include the correlationId from the error
                  response for investigation.
                docs: https://conduit-v2.mintlify.app/errors#internal-error
                instance: /v2/...
                correlationId: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
                timestamp: '2026-01-15T09:30:00.000Z'
components:
  schemas:
    ExternalRequirementsResponseDto:
      type: object
      properties:
        schemaVersion:
          type: string
          description: >-
            Discovery response schema version. Bumps on any breaking
            discovery-response change (field renamed, removed, type changed,
            conditional semantics changed). Distinct from the webhook envelope's
            `apiVersion` which tracks the API major. Clients pin the literal and
            fail loudly on mismatch; servers do not negotiate.
          enum:
            - '3'
        context:
          type: string
          enum:
            - onboarding
            - feature
            - order
          description: The discovery context that produced this requirements set.
          example: onboarding
        country:
          type: string
          pattern: ^[A-Z]{3}$
          description: >-
            ISO 3166-1 alpha-3 country code the requirements were resolved for.
            Always three uppercase letters.
          example: USA
        fields:
          type: array
          items:
            type: object
            properties:
              pointer:
                type: string
                description: >-
                  RFC 6901 JSON Pointer to the field in the submission payload.
                  Always starts with /. Array indices appear as integers.
                example: /businessInfo/taxId
              label:
                type: string
                description: Human-readable label for display
                example: Tax Identification Number
              helpText:
                description: >-
                  One-line guidance for the field, intended to render as a
                  tooltip / info pill next to the label. Plain text, no markup.
                  For `businessInfo.taxId` and `businessInfo.businessEntityId`
                  this is the country-specific identifier description from
                  `countries.json` (with the issuing authority prefixed when
                  known, e.g. 'Issued by HMRC.'). For other fields it is
                  universal copy from the server-side field registry. Silently
                  absent when neither source has guidance on file. See
                  api-conventions §5.1.5.
                example: >-
                  Issued by HMRC. 10-digit number; auto-assigned on CT
                  registration; appears on HMRC correspondence. VAT Registration
                  Number (GB + 9 digits; XI prefix for NI–EU trade) is
                  supplementary — collect separately if VAT-registered.
                type: string
              type:
                type: string
                enum:
                  - string
                  - number
                  - integer
                  - boolean
                  - date
                  - datetime
                  - email
                  - url
                  - phone
                  - country
                  - enum
                  - stringArray
                  - enumArray
                description: Data type of the field
                example: string
              required:
                type: boolean
                description: Whether the field is required at submit
              group:
                description: >-
                  Section grouping code for renderers. Stable camelCase token
                  drawn from a closed set per discovery context (onboarding
                  today: `businessInfo`, `companyClassification`,
                  `registeredAddress`, `operatingAddress`, `businessActivity`,
                  `activity`, `regulatoryHistory`, `certification`,
                  `customAnswers`; `activity` carries an individual subject's
                  own activity envelope, where `businessActivity` carries a
                  business subject's; `customAnswers` carries operator-authored
                  questions). Omitted on top-level scalars without a section and
                  on fields nested inside `individualRequirements[].fields[]`
                  (already a logical group). Presentation metadata; submit
                  ignores it.
                type: string
              mustEqual:
                description: >-
                  Required-with-const marker. Submit enforces strict equality on
                  the field value (not just presence). Most common case:
                  legal-certification booleans
                  (`certification.termsAndConditions: { required: true,
                  mustEqual: true }`) where `false` submits are rejected.
                  Omitted when not constrained to a single value.
                anyOf:
                  - type: boolean
                  - type: string
                  - type: number
              constraints:
                description: >-
                  Per-value limits on this field alone, enforceable client-side.
                  Satisfying them does not by itself clear submit: a value must
                  also satisfy the field's `allowedValues`, its `mustEqual`, and
                  every `conditionalOverride` whose conditions hold. Some
                  `pattern` values state only a canonical spelling, and submit
                  can accept equivalent spellings such a pattern does not list.
                type: object
                properties:
                  pattern:
                    description: >-
                      Regex stating the canonical form of the value. A value
                      that matches it is in the form submit expects; for some
                      fields, submit is more lenient than this pattern and can
                      accept spellings it does not state, so a value outside it
                      is not always refused.
                    example: ^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$
                    type: string
                  example:
                    description: Example value matching the pattern
                    example: 12.345.678/0001-95
                    type: string
                  format:
                    description: >-
                      Advertised server-enforced semantic format marker. Closed
                      enum: `safeString` (structured short fields — rejects
                      control characters, HTML tags, and punctuation outside the
                      documented allowlist), `prose` (free-text fields — allows
                      ordinary punctuation and multi-line text, rejecting
                      control characters, invisible-format characters,
                      line/paragraph separators, and lone surrogates) or `ip`
                      (an IPv4 or IPv6 address — no zone identifier, no leading
                      zeros in IPv4 octets). The server enforces the rule at
                      submit; the marker advertises it so clients can
                      pre-validate. Arbitrary regex aliases belong in `pattern`.
                    type: string
                    enum:
                      - safeString
                      - prose
                      - ip
                  minLength:
                    description: Minimum string length
                    type: integer
                    minimum: -9007199254740991
                    maximum: 9007199254740991
                  maxLength:
                    description: Maximum string length
                    type: integer
                    minimum: -9007199254740991
                    maximum: 9007199254740991
                  min:
                    description: Minimum numeric value
                    type: number
                  max:
                    description: Maximum numeric value
                    type: number
                  minDate:
                    description: >-
                      Earliest allowed date as ISO 8601 (YYYY-MM-DD) or the
                      literal 'today'
                    example: '1800-01-01'
                    type: string
                  maxDate:
                    description: >-
                      Latest allowed date as ISO 8601 (YYYY-MM-DD) or the
                      literal 'today'
                    example: today
                    type: string
                  maxDateTime:
                    description: >-
                      Latest allowed instant for a datetime field: the literal
                      'now'. A value up to five minutes ahead of the server
                      clock is accepted to absorb clock skew.
                    example: now
                    type: string
                    enum:
                      - now
                  minAgeYears:
                    description: Minimum age in years (for date-of-birth-style fields)
                    type: integer
                    minimum: -9007199254740991
                    maximum: 9007199254740991
                  maxAgeYears:
                    description: Maximum age in years (for date-of-birth-style fields)
                    type: integer
                    minimum: -9007199254740991
                    maximum: 9007199254740991
                  checksum:
                    description: >-
                      A check digit rule the value must pass beyond `pattern`:
                      `aba` for a US routing number, `iban` for an international
                      bank account number (mod-97).
                    type: string
                    enum:
                      - aba
                      - iban
                additionalProperties: false
              conditions:
                description: >-
                  Conditional applicability rules. The field applies (is shown /
                  required) only when every condition evaluates true against the
                  current submission. Empty / absent means unconditional.
                type: array
                items:
                  type: object
                  properties:
                    pointer:
                      type: string
                      description: >-
                        RFC 6901 JSON Pointer to the submitted-data field this
                        condition reads. Resolution is governed by the sibling
                        scope (root by default; person-scoped when
                        scope='person').
                      example: /companyClassification/legalStructure
                    operator:
                      type: string
                      enum:
                        - eq
                        - in
                        - not_in
                        - exists
                        - is_true
                        - is_false
                      description: >-
                        Comparison operator. The field is required / applies
                        only when the condition evaluates true against the
                        current submitted data.
                      example: eq
                    value:
                      description: Single comparison value, used with eq / exists operators
                      type: string
                    values:
                      description: >-
                        Array of comparison values, used with in / not_in
                        operators
                      type: array
                      items:
                        type: string
                    scope:
                      description: >-
                        Evaluation scope for `pointer`. Default `root` evaluates
                        against the top-level submission; `person` evaluates
                        against the current `ownership.persons[i]` row (used
                        inside `individualRequirements[].fields[].conditions`).
                      type: string
                      enum:
                        - root
                        - person
                  required:
                    - pointer
                    - operator
                  additionalProperties: false
              allowedValues:
                description: >-
                  Allowed values for enum / enumArray fields. The submitted
                  value MUST be one of these.
                example:
                  - LLC
                  - CORPORATION
                  - PARTNERSHIP
                type: array
                items:
                  type: string
              options:
                description: >-
                  Structured per-option metadata for enum fields with display /
                  grouping hints (label, abbr, description, category). `value`
                  mirrors an entry in `allowedValues`. Present when the
                  projector has localized data to surface (e.g. country-specific
                  legal structures); enum fields without rich metadata use
                  `allowedValues` alone.
                type: array
                items:
                  type: object
                  properties:
                    value:
                      type: string
                      description: >-
                        Submitted value. Must be one of the entries in the
                        sibling `allowedValues` array.
                      example: Sociedad Anónima
                    label:
                      type: string
                      description: Human-readable label for display
                      example: Sociedad Anónima
                    abbr:
                      type: string
                      description: Short-form / acronym for the option
                      example: S.A.
                      nullable: true
                    description:
                      description: Long-form description of the option
                      type: string
                    category:
                      type: string
                      enum:
                        - Corp
                        - LLC
                        - Sole Proprietorship
                        - Partnership
                        - Other
                        - regulatory_review
                      description: >-
                        Out-of-band metadata for an option that affects how it
                        should be rendered or handled. Values: the
                        legal-structure canonical bucket (`Corp` / `LLC` / `Sole
                        Proprietorship` / `Partnership` / `Other`) — used to map
                        the localised `value` to a standardised type; and
                        `regulatory_review` — indicates this option is subject
                        to additional regulatory review and may warrant a
                        pre-submission warning to the user. Silently absent on
                        options that carry no such metadata.
                  required:
                    - value
                    - label
                  additionalProperties: false
              conditionalOverrides:
                description: >-
                  Extra constraints that apply only while their own conditions
                  hold. Each element carries a `conditions` array read exactly
                  like the field's own `conditions` — every condition must hold,
                  and `scope: 'person'` resolves the pointer against the current
                  `ownership.persons[i]` row — plus the `constraints` submit
                  adds for that case. Three cases ship. An address states what
                  submit keys on that address's own country: a person's
                  `/address/state` carries the US subdivision pattern and
                  `/address/postalCode` the US ZIP pattern while that same
                  person's `/address/country` is `USA` (`scope: 'person'`), and
                  the business's `/operatingAddress/state` and
                  `/operatingAddress/postalCode` carry the same two while
                  `/operatingAddress/country` is `USA`, read at the root of the
                  body because the condition names no scope. A person's
                  `/taxIdNumber` carries the US Social Security Number pattern
                  while that same person's `/taxIdType` is `SSN`. When two or
                  more requirement rules declare one field and a rule's check
                  depends on a condition discovery cannot settle (most often a
                  `scope: 'person'` condition), that rule's check is an element
                  too: its `constraints` and, for an enum field, its
                  `allowedValues`. Some overrides' `pattern` states only the
                  canonical value to send, not the full set submit accepts: the
                  US subdivision pattern states the two-letter code with or
                  without the `US-` prefix, while submit also accepts the full
                  state name and other spellings. Apply every element whose
                  conditions hold ON TOP OF the field's own `constraints`, never
                  in place of them: the value must match the field-level
                  `pattern` and every override `pattern` that applies, and a
                  bound named twice tightens to the stricter value. The property
                  is additive and a client may ignore it, in which case the
                  field reads exactly as it did before the property existed and
                  submit can still reject a value the override would have named.
                  Silently absent when the field carries no conditional case.
                type: array
                items:
                  type: object
                  properties:
                    conditions:
                      type: array
                      items:
                        type: object
                        properties:
                          pointer:
                            type: string
                            description: >-
                              RFC 6901 JSON Pointer to the submitted-data field
                              this condition reads. Resolution is governed by
                              the sibling scope (root by default; person-scoped
                              when scope='person').
                            example: /companyClassification/legalStructure
                          operator:
                            type: string
                            enum:
                              - eq
                              - in
                              - not_in
                              - exists
                              - is_true
                              - is_false
                            description: >-
                              Comparison operator. The field is required /
                              applies only when the condition evaluates true
                              against the current submitted data.
                            example: eq
                          value:
                            description: >-
                              Single comparison value, used with eq / exists
                              operators
                            type: string
                          values:
                            description: >-
                              Array of comparison values, used with in / not_in
                              operators
                            type: array
                            items:
                              type: string
                          scope:
                            description: >-
                              Evaluation scope for `pointer`. Default `root`
                              evaluates against the top-level submission;
                              `person` evaluates against the current
                              `ownership.persons[i]` row (used inside
                              `individualRequirements[].fields[].conditions`).
                            type: string
                            enum:
                              - root
                              - person
                        required:
                          - pointer
                          - operator
                        additionalProperties: false
                      description: >-
                        Conditions that must ALL hold for this override to
                        apply. Same shape and evaluation as `conditions` on the
                        field itself, `scope` included.
                    constraints:
                      type: object
                      properties:
                        pattern:
                          description: >-
                            Regex stating the canonical form of the value. A
                            value that matches it is in the form submit expects;
                            for some fields, submit is more lenient than this
                            pattern and can accept spellings it does not state,
                            so a value outside it is not always refused.
                          example: ^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$
                          type: string
                        example:
                          description: Example value matching the pattern
                          example: 12.345.678/0001-95
                          type: string
                        format:
                          description: >-
                            Advertised server-enforced semantic format marker.
                            Closed enum: `safeString` (structured short fields —
                            rejects control characters, HTML tags, and
                            punctuation outside the documented allowlist),
                            `prose` (free-text fields — allows ordinary
                            punctuation and multi-line text, rejecting control
                            characters, invisible-format characters,
                            line/paragraph separators, and lone surrogates) or
                            `ip` (an IPv4 or IPv6 address — no zone identifier,
                            no leading zeros in IPv4 octets). The server
                            enforces the rule at submit; the marker advertises
                            it so clients can pre-validate. Arbitrary regex
                            aliases belong in `pattern`.
                          type: string
                          enum:
                            - safeString
                            - prose
                            - ip
                        minLength:
                          description: Minimum string length
                          type: integer
                          minimum: -9007199254740991
                          maximum: 9007199254740991
                        maxLength:
                          description: Maximum string length
                          type: integer
                          minimum: -9007199254740991
                          maximum: 9007199254740991
                        min:
                          description: Minimum numeric value
                          type: number
                        max:
                          description: Maximum numeric value
                          type: number
                        minDate:
                          description: >-
                            Earliest allowed date as ISO 8601 (YYYY-MM-DD) or
                            the literal 'today'
                          example: '1800-01-01'
                          type: string
                        maxDate:
                          description: >-
                            Latest allowed date as ISO 8601 (YYYY-MM-DD) or the
                            literal 'today'
                          example: today
                          type: string
                        maxDateTime:
                          description: >-
                            Latest allowed instant for a datetime field: the
                            literal 'now'. A value up to five minutes ahead of
                            the server clock is accepted to absorb clock skew.
                          example: now
                          type: string
                          enum:
                            - now
                        minAgeYears:
                          description: >-
                            Minimum age in years (for date-of-birth-style
                            fields)
                          type: integer
                          minimum: -9007199254740991
                          maximum: 9007199254740991
                        maxAgeYears:
                          description: >-
                            Maximum age in years (for date-of-birth-style
                            fields)
                          type: integer
                          minimum: -9007199254740991
                          maximum: 9007199254740991
                        checksum:
                          description: >-
                            A check digit rule the value must pass beyond
                            `pattern`: `aba` for a US routing number, `iban` for
                            an international bank account number (mod-97).
                          type: string
                          enum:
                            - aba
                            - iban
                      additionalProperties: false
                      description: >-
                        Constraints submit adds while the conditions hold. They
                        narrow the field, never widen it, and they do not
                        replace the field's own `constraints`: `pattern` is a
                        SECOND regex that states the canonical form for this
                        case, applied as well as the field-level `pattern`, and
                        a bound named on both takes whichever value is stricter.
                        As at field level, submit can be more lenient than some
                        of these patterns state. `example` is a value valid
                        under this override. Empty when the override narrows
                        only `allowedValues`.
                    allowedValues:
                      description: >-
                        Allowed values for an enum / enumArray field while the
                        conditions hold: a subset of the field's own
                        `allowedValues`. Submit refuses a value outside it in
                        that case. Omitted when the override does not narrow the
                        values.
                      example:
                        - SSN
                      type: array
                      items:
                        type: string
                  required:
                    - conditions
                    - constraints
                  additionalProperties: false
            required:
              - pointer
              - label
              - type
              - required
          description: >-
            Scalar fields the integrator must collect, with format hints and
            allowedValues for enum fields.
        documents:
          type: array
          items:
            type: object
            properties:
              canonicalType:
                type: string
                enum:
                  - BUSINESS_REGISTRATION
                  - ARTICLES_OF_INCORPORATION
                  - TAX_CERTIFICATE
                  - OPERATING_LICENSE
                  - REGULATORY_LICENSE
                  - SHAREHOLDERS_REGISTRY
                  - DIRECTORS_REGISTRY
                  - AUTHORIZATION_TO_ACT
                  - PROOF_OF_ADDRESS
                  - CERTIFICATE_OF_GOOD_STANDING
                  - FLOW_OF_FUNDS
                  - AUDITED_FINANCIAL_STATEMENT
                  - BANK_STATEMENT
                  - ORG_STRUCTURE_CHART
                  - AML_AUDIT
                  - COMPLIANCE_POLICY
                  - INSTITUTIONAL_INVESTOR_DOCUMENTATION
                  - IDENTITY_VERIFICATION
                  - IDENTITY_VERIFICATION_ATTESTATION
                  - EDD_EVIDENCE
                  - BANK_VERIFICATION_LETTER
                  - INVOICE
                  - CONTRACT
                  - PAYROLL_REGISTER
                  - INVESTMENT_AGREEMENT
                  - OTHER
                description: >-
                  Canonical category label for this document slot. Collect a
                  document matching the title or category and upload it with
                  `POST /v2/documents`. Setting that upload's optional `type` to
                  this value records the file against this slot; Conduit still
                  identifies the document itself, and that determination is what
                  applies.
              title:
                type: string
                description: Human-readable artifact name for UI display
                example: Articles of Incorporation
              from:
                description: Issuing authority when known
                type: string
              alternatives:
                description: >-
                  Acceptable alternative artifacts. Collect ANY ONE of these to
                  satisfy the requirement.
                type: array
                items:
                  type: object
                  properties:
                    title:
                      type: string
                      description: Human-readable artifact name for UI display
                      example: Certificate of Incorporation
                    from:
                      description: Issuing authority when known
                      type: string
                  required:
                    - title
                  additionalProperties: false
              requiredArtifacts:
                description: >-
                  Present only when the slot mixes required artifacts with
                  alternative or optional artifacts. Single required-only slots
                  are flattened to the row itself.
                type: array
                items:
                  type: object
                  properties:
                    title:
                      type: string
                      description: Human-readable artifact name for UI display
                      example: Certificate of Incorporation
                    from:
                      description: Issuing authority when known
                      type: string
                  required:
                    - title
                  additionalProperties: false
              optionalArtifacts:
                description: >-
                  Recommended artifacts for this canonical document slot. These
                  are not required for submission.
                type: array
                items:
                  type: object
                  properties:
                    title:
                      type: string
                      description: Human-readable artifact name for UI display
                      example: Certificate of Incorporation
                    from:
                      description: Issuing authority when known
                      type: string
                  required:
                    - title
                  additionalProperties: false
              optional:
                description: >-
                  True when collection is recommended but not required for
                  submission.
                type: boolean
              minCount:
                description: >-
                  Number of files of this canonical type the integrator must
                  upload. Absent / 1 means a single file satisfies the slot;
                  values greater than 1 require N distinct uploads (e.g. 3
                  consecutive bank statements). Server-side validation at submit
                  enforces the same floor.
                type: integer
                minimum: 1
                maximum: 9007199254740991
              groupId:
                description: >-
                  When present, this document row is one branch of an `any-of`
                  alternation. Every row sharing the same `groupId` forms a
                  single decision point: satisfying ANY branch's own minCount
                  satisfies the group. The integrator should render grouped rows
                  together (e.g. a single slab with each branch as a
                  sub-option). The `group:` prefix namespaces the id away from
                  canonical type names (which are SCREAMING_SNAKE_CASE and never
                  contain `:` or `+`).
                example: group:any-of:AUDITED_FINANCIAL_STATEMENT+BANK_STATEMENT
                type: string
              policyFallback:
                description: >-
                  True when this row exists because the requirement rule asks
                  for the canonicalType but the country has no
                  jurisdiction-specific document. Conduit substitutes a generic,
                  company-producible alternative (e.g. an internal share
                  register, board resolution, utility bill). The customer is
                  still expected to provide evidence; see `guidance` for what to
                  collect.
                type: boolean
              guidance:
                description: >-
                  One-line collection guidance shown to the integrator's end
                  customer: what evidence to collect for this slot. Present on
                  `policyFallback: true` rows (what to supply absent a
                  jurisdiction-specific document) and on address-targeted
                  proof-of-address rows (which address the document must show —
                  registered vs operating).
                type: string
              addressTarget:
                description: >-
                  Which submitted address this proof-of-address row must be
                  shown to prove. Present ONLY on `PROOF_OF_ADDRESS` rows that
                  are address-targeted: the requirement can surface as two rows
                  sharing `canonicalType: "PROOF_OF_ADDRESS"`, disambiguated by
                  this field (`registered` always; `operating` when the
                  operating address differs). Both must be collected.
                  Machine-readable key for these rows — do NOT dedupe
                  address-targeted rows by `canonicalType`.
                type: string
                enum:
                  - registered
                  - operating
              conditions:
                description: >-
                  Present when the document is owed only conditionally. The
                  document is owed only when every condition holds on your
                  submission; evaluate them like a field's `conditions`.
                type: array
                items:
                  type: object
                  properties:
                    pointer:
                      type: string
                      description: >-
                        RFC 6901 JSON Pointer to the submitted-data field this
                        condition reads. Resolution is governed by the sibling
                        scope (root by default; person-scoped when
                        scope='person').
                      example: /companyClassification/legalStructure
                    operator:
                      type: string
                      enum:
                        - eq
                        - in
                        - not_in
                        - exists
                        - is_true
                        - is_false
                      description: >-
                        Comparison operator. The field is required / applies
                        only when the condition evaluates true against the
                        current submitted data.
                      example: eq
                    value:
                      description: Single comparison value, used with eq / exists operators
                      type: string
                    values:
                      description: >-
                        Array of comparison values, used with in / not_in
                        operators
                      type: array
                      items:
                        type: string
                    scope:
                      description: >-
                        Evaluation scope for `pointer`. Default `root` evaluates
                        against the top-level submission; `person` evaluates
                        against the current `ownership.persons[i]` row (used
                        inside `individualRequirements[].fields[].conditions`).
                      type: string
                      enum:
                        - root
                        - person
                  required:
                    - pointer
                    - operator
                  additionalProperties: false
            required:
              - canonicalType
              - title
            additionalProperties: false
          description: >-
            Customer-level documents to collect. Rows are usually keyed by
            canonicalType — EXCEPT address-targeted proof-of-address, which can
            appear as two rows sharing canonicalType `PROOF_OF_ADDRESS`
            disambiguated by `addressTarget` (registered / operating); collect
            both, and key those rows on `addressTarget`, not canonicalType
            alone. Upload every requiredArtifacts[] entry and any one
            alternatives[] entry when present, otherwise upload the row itself
            via POST /v2/documents.
        minDocuments:
          type: integer
          minimum: 0
          maximum: 9007199254740991
          description: >-
            Document floor: the minimum number of documents POST /v2/onboarding
            accepts — currently 0 or 1. `1` means the submission must carry at
            least one document, counting `documentIds` at the top level and on
            each person; a submission with none anywhere is rejected with 422
            ONBOARDING_NOT_READY. `0` means documents are optional at submit.
            Submit checks the count, not the type: individual `documents[]` rows
            are a checklist of acceptable types and do not each carry a required
            flag, and per-document completeness is assessed after submission.
          example: 1
        individualRequirements:
          type: array
          items:
            anyOf:
              - type: object
                properties:
                  role:
                    type: string
                    description: >-
                      Role discriminant. BENEFICIAL_OWNER is the only role that
                      carries `ownershipThreshold`.
                    enum:
                      - BENEFICIAL_OWNER
                  minCount:
                    type: integer
                    minimum: 0
                    maximum: 9007199254740991
                    description: >-
                      Minimum number of persons that must fill this role.
                      BENEFICIAL_OWNER may be 0 when the rule only conditionally
                      requires beneficial-owner disclosure (e.g. only when
                      actual ownership crosses `ownershipThreshold`).
                  maxCount:
                    description: >-
                      Maximum number of persons accepted under this role. Absent
                      when unbounded.
                    type: integer
                    minimum: -9007199254740991
                    maximum: 9007199254740991
                  ownershipThreshold:
                    example: 25
                    type: number
                    description: >-
                      Minimum ownership percentage qualifying a person as a
                      beneficial owner under this rule. Absent when the rule
                      doesn't constrain ownership disclosure.
                  fields:
                    type: array
                    items:
                      type: object
                      properties:
                        pointer:
                          type: string
                          description: >-
                            RFC 6901 JSON Pointer to the field in the submission
                            payload. Always starts with /. Array indices appear
                            as integers.
                          example: /businessInfo/taxId
                        label:
                          type: string
                          description: Human-readable label for display
                          example: Tax Identification Number
                        helpText:
                          description: >-
                            One-line guidance for the field, intended to render
                            as a tooltip / info pill next to the label. Plain
                            text, no markup. For `businessInfo.taxId` and
                            `businessInfo.businessEntityId` this is the
                            country-specific identifier description from
                            `countries.json` (with the issuing authority
                            prefixed when known, e.g. 'Issued by HMRC.'). For
                            other fields it is universal copy from the
                            server-side field registry. Silently absent when
                            neither source has guidance on file. See
                            api-conventions §5.1.5.
                          example: >-
                            Issued by HMRC. 10-digit number; auto-assigned on CT
                            registration; appears on HMRC correspondence. VAT
                            Registration Number (GB + 9 digits; XI prefix for
                            NI–EU trade) is supplementary — collect separately
                            if VAT-registered.
                          type: string
                        type:
                          type: string
                          enum:
                            - string
                            - number
                            - integer
                            - boolean
                            - date
                            - datetime
                            - email
                            - url
                            - phone
                            - country
                            - enum
                            - stringArray
                            - enumArray
                          description: Data type of the field
                          example: string
                        required:
                          type: boolean
                          description: Whether the field is required at submit
                        group:
                          description: >-
                            Section grouping code for renderers. Stable
                            camelCase token drawn from a closed set per
                            discovery context (onboarding today: `businessInfo`,
                            `companyClassification`, `registeredAddress`,
                            `operatingAddress`, `businessActivity`, `activity`,
                            `regulatoryHistory`, `certification`,
                            `customAnswers`; `activity` carries an individual
                            subject's own activity envelope, where
                            `businessActivity` carries a business subject's;
                            `customAnswers` carries operator-authored
                            questions). Omitted on top-level scalars without a
                            section and on fields nested inside
                            `individualRequirements[].fields[]` (already a
                            logical group). Presentation metadata; submit
                            ignores it.
                          type: string
                        mustEqual:
                          description: >-
                            Required-with-const marker. Submit enforces strict
                            equality on the field value (not just presence).
                            Most common case: legal-certification booleans
                            (`certification.termsAndConditions: { required:
                            true, mustEqual: true }`) where `false` submits are
                            rejected. Omitted when not constrained to a single
                            value.
                          anyOf:
                            - type: boolean
                            - type: string
                            - type: number
                        constraints:
                          description: >-
                            Per-value limits on this field alone, enforceable
                            client-side. Satisfying them does not by itself
                            clear submit: a value must also satisfy the field's
                            `allowedValues`, its `mustEqual`, and every
                            `conditionalOverride` whose conditions hold. Some
                            `pattern` values state only a canonical spelling,
                            and submit can accept equivalent spellings such a
                            pattern does not list.
                          type: object
                          properties:
                            pattern:
                              description: >-
                                Regex stating the canonical form of the value. A
                                value that matches it is in the form submit
                                expects; for some fields, submit is more lenient
                                than this pattern and can accept spellings it
                                does not state, so a value outside it is not
                                always refused.
                              example: ^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$
                              type: string
                            example:
                              description: Example value matching the pattern
                              example: 12.345.678/0001-95
                              type: string
                            format:
                              description: >-
                                Advertised server-enforced semantic format
                                marker. Closed enum: `safeString` (structured
                                short fields — rejects control characters, HTML
                                tags, and punctuation outside the documented
                                allowlist), `prose` (free-text fields — allows
                                ordinary punctuation and multi-line text,
                                rejecting control characters, invisible-format
                                characters, line/paragraph separators, and lone
                                surrogates) or `ip` (an IPv4 or IPv6 address —
                                no zone identifier, no leading zeros in IPv4
                                octets). The server enforces the rule at submit;
                                the marker advertises it so clients can
                                pre-validate. Arbitrary regex aliases belong in
                                `pattern`.
                              type: string
                              enum:
                                - safeString
                                - prose
                                - ip
                            minLength:
                              description: Minimum string length
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            maxLength:
                              description: Maximum string length
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            min:
                              description: Minimum numeric value
                              type: number
                            max:
                              description: Maximum numeric value
                              type: number
                            minDate:
                              description: >-
                                Earliest allowed date as ISO 8601 (YYYY-MM-DD)
                                or the literal 'today'
                              example: '1800-01-01'
                              type: string
                            maxDate:
                              description: >-
                                Latest allowed date as ISO 8601 (YYYY-MM-DD) or
                                the literal 'today'
                              example: today
                              type: string
                            maxDateTime:
                              description: >-
                                Latest allowed instant for a datetime field: the
                                literal 'now'. A value up to five minutes ahead
                                of the server clock is accepted to absorb clock
                                skew.
                              example: now
                              type: string
                              enum:
                                - now
                            minAgeYears:
                              description: >-
                                Minimum age in years (for date-of-birth-style
                                fields)
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            maxAgeYears:
                              description: >-
                                Maximum age in years (for date-of-birth-style
                                fields)
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            checksum:
                              description: >-
                                A check digit rule the value must pass beyond
                                `pattern`: `aba` for a US routing number, `iban`
                                for an international bank account number
                                (mod-97).
                              type: string
                              enum:
                                - aba
                                - iban
                          additionalProperties: false
                        conditions:
                          description: >-
                            Conditional applicability rules. The field applies
                            (is shown / required) only when every condition
                            evaluates true against the current submission. Empty
                            / absent means unconditional.
                          type: array
                          items:
                            type: object
                            properties:
                              pointer:
                                type: string
                                description: >-
                                  RFC 6901 JSON Pointer to the submitted-data
                                  field this condition reads. Resolution is
                                  governed by the sibling scope (root by
                                  default; person-scoped when scope='person').
                                example: /companyClassification/legalStructure
                              operator:
                                type: string
                                enum:
                                  - eq
                                  - in
                                  - not_in
                                  - exists
                                  - is_true
                                  - is_false
                                description: >-
                                  Comparison operator. The field is required /
                                  applies only when the condition evaluates true
                                  against the current submitted data.
                                example: eq
                              value:
                                description: >-
                                  Single comparison value, used with eq / exists
                                  operators
                                type: string
                              values:
                                description: >-
                                  Array of comparison values, used with in /
                                  not_in operators
                                type: array
                                items:
                                  type: string
                              scope:
                                description: >-
                                  Evaluation scope for `pointer`. Default `root`
                                  evaluates against the top-level submission;
                                  `person` evaluates against the current
                                  `ownership.persons[i]` row (used inside
                                  `individualRequirements[].fields[].conditions`).
                                type: string
                                enum:
                                  - root
                                  - person
                            required:
                              - pointer
                              - operator
                            additionalProperties: false
                        allowedValues:
                          description: >-
                            Allowed values for enum / enumArray fields. The
                            submitted value MUST be one of these.
                          example:
                            - LLC
                            - CORPORATION
                            - PARTNERSHIP
                          type: array
                          items:
                            type: string
                        options:
                          description: >-
                            Structured per-option metadata for enum fields with
                            display / grouping hints (label, abbr, description,
                            category). `value` mirrors an entry in
                            `allowedValues`. Present when the projector has
                            localized data to surface (e.g. country-specific
                            legal structures); enum fields without rich metadata
                            use `allowedValues` alone.
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                description: >-
                                  Submitted value. Must be one of the entries in
                                  the sibling `allowedValues` array.
                                example: Sociedad Anónima
                              label:
                                type: string
                                description: Human-readable label for display
                                example: Sociedad Anónima
                              abbr:
                                type: string
                                description: Short-form / acronym for the option
                                example: S.A.
                                nullable: true
                              description:
                                description: Long-form description of the option
                                type: string
                              category:
                                type: string
                                enum:
                                  - Corp
                                  - LLC
                                  - Sole Proprietorship
                                  - Partnership
                                  - Other
                                  - regulatory_review
                                description: >-
                                  Out-of-band metadata for an option that
                                  affects how it should be rendered or handled.
                                  Values: the legal-structure canonical bucket
                                  (`Corp` / `LLC` / `Sole Proprietorship` /
                                  `Partnership` / `Other`) — used to map the
                                  localised `value` to a standardised type; and
                                  `regulatory_review` — indicates this option is
                                  subject to additional regulatory review and
                                  may warrant a pre-submission warning to the
                                  user. Silently absent on options that carry no
                                  such metadata.
                            required:
                              - value
                              - label
                            additionalProperties: false
                        conditionalOverrides:
                          description: >-
                            Extra constraints that apply only while their own
                            conditions hold. Each element carries a `conditions`
                            array read exactly like the field's own `conditions`
                            — every condition must hold, and `scope: 'person'`
                            resolves the pointer against the current
                            `ownership.persons[i]` row — plus the `constraints`
                            submit adds for that case. Three cases ship. An
                            address states what submit keys on that address's
                            own country: a person's `/address/state` carries the
                            US subdivision pattern and `/address/postalCode` the
                            US ZIP pattern while that same person's
                            `/address/country` is `USA` (`scope: 'person'`), and
                            the business's `/operatingAddress/state` and
                            `/operatingAddress/postalCode` carry the same two
                            while `/operatingAddress/country` is `USA`, read at
                            the root of the body because the condition names no
                            scope. A person's `/taxIdNumber` carries the US
                            Social Security Number pattern while that same
                            person's `/taxIdType` is `SSN`. When two or more
                            requirement rules declare one field and a rule's
                            check depends on a condition discovery cannot settle
                            (most often a `scope: 'person'` condition), that
                            rule's check is an element too: its `constraints`
                            and, for an enum field, its `allowedValues`. Some
                            overrides' `pattern` states only the canonical value
                            to send, not the full set submit accepts: the US
                            subdivision pattern states the two-letter code with
                            or without the `US-` prefix, while submit also
                            accepts the full state name and other spellings.
                            Apply every element whose conditions hold ON TOP OF
                            the field's own `constraints`, never in place of
                            them: the value must match the field-level `pattern`
                            and every override `pattern` that applies, and a
                            bound named twice tightens to the stricter value.
                            The property is additive and a client may ignore it,
                            in which case the field reads exactly as it did
                            before the property existed and submit can still
                            reject a value the override would have named.
                            Silently absent when the field carries no
                            conditional case.
                          type: array
                          items:
                            type: object
                            properties:
                              conditions:
                                type: array
                                items:
                                  type: object
                                  properties:
                                    pointer:
                                      type: string
                                      description: >-
                                        RFC 6901 JSON Pointer to the
                                        submitted-data field this condition
                                        reads. Resolution is governed by the
                                        sibling scope (root by default;
                                        person-scoped when scope='person').
                                      example: /companyClassification/legalStructure
                                    operator:
                                      type: string
                                      enum:
                                        - eq
                                        - in
                                        - not_in
                                        - exists
                                        - is_true
                                        - is_false
                                      description: >-
                                        Comparison operator. The field is
                                        required / applies only when the
                                        condition evaluates true against the
                                        current submitted data.
                                      example: eq
                                    value:
                                      description: >-
                                        Single comparison value, used with eq /
                                        exists operators
                                      type: string
                                    values:
                                      description: >-
                                        Array of comparison values, used with in
                                        / not_in operators
                                      type: array
                                      items:
                                        type: string
                                    scope:
                                      description: >-
                                        Evaluation scope for `pointer`. Default
                                        `root` evaluates against the top-level
                                        submission; `person` evaluates against
                                        the current `ownership.persons[i]` row
                                        (used inside
                                        `individualRequirements[].fields[].conditions`).
                                      type: string
                                      enum:
                                        - root
                                        - person
                                  required:
                                    - pointer
                                    - operator
                                  additionalProperties: false
                                description: >-
                                  Conditions that must ALL hold for this
                                  override to apply. Same shape and evaluation
                                  as `conditions` on the field itself, `scope`
                                  included.
                              constraints:
                                type: object
                                properties:
                                  pattern:
                                    description: >-
                                      Regex stating the canonical form of the
                                      value. A value that matches it is in the
                                      form submit expects; for some fields,
                                      submit is more lenient than this pattern
                                      and can accept spellings it does not
                                      state, so a value outside it is not always
                                      refused.
                                    example: ^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$
                                    type: string
                                  example:
                                    description: Example value matching the pattern
                                    example: 12.345.678/0001-95
                                    type: string
                                  format:
                                    description: >-
                                      Advertised server-enforced semantic format
                                      marker. Closed enum: `safeString`
                                      (structured short fields — rejects control
                                      characters, HTML tags, and punctuation
                                      outside the documented allowlist), `prose`
                                      (free-text fields — allows ordinary
                                      punctuation and multi-line text, rejecting
                                      control characters, invisible-format
                                      characters, line/paragraph separators, and
                                      lone surrogates) or `ip` (an IPv4 or IPv6
                                      address — no zone identifier, no leading
                                      zeros in IPv4 octets). The server enforces
                                      the rule at submit; the marker advertises
                                      it so clients can pre-validate. Arbitrary
                                      regex aliases belong in `pattern`.
                                    type: string
                                    enum:
                                      - safeString
                                      - prose
                                      - ip
                                  minLength:
                                    description: Minimum string length
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  maxLength:
                                    description: Maximum string length
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  min:
                                    description: Minimum numeric value
                                    type: number
                                  max:
                                    description: Maximum numeric value
                                    type: number
                                  minDate:
                                    description: >-
                                      Earliest allowed date as ISO 8601
                                      (YYYY-MM-DD) or the literal 'today'
                                    example: '1800-01-01'
                                    type: string
                                  maxDate:
                                    description: >-
                                      Latest allowed date as ISO 8601
                                      (YYYY-MM-DD) or the literal 'today'
                                    example: today
                                    type: string
                                  maxDateTime:
                                    description: >-
                                      Latest allowed instant for a datetime
                                      field: the literal 'now'. A value up to
                                      five minutes ahead of the server clock is
                                      accepted to absorb clock skew.
                                    example: now
                                    type: string
                                    enum:
                                      - now
                                  minAgeYears:
                                    description: >-
                                      Minimum age in years (for
                                      date-of-birth-style fields)
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  maxAgeYears:
                                    description: >-
                                      Maximum age in years (for
                                      date-of-birth-style fields)
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  checksum:
                                    description: >-
                                      A check digit rule the value must pass
                                      beyond `pattern`: `aba` for a US routing
                                      number, `iban` for an international bank
                                      account number (mod-97).
                                    type: string
                                    enum:
                                      - aba
                                      - iban
                                additionalProperties: false
                                description: >-
                                  Constraints submit adds while the conditions
                                  hold. They narrow the field, never widen it,
                                  and they do not replace the field's own
                                  `constraints`: `pattern` is a SECOND regex
                                  that states the canonical form for this case,
                                  applied as well as the field-level `pattern`,
                                  and a bound named on both takes whichever
                                  value is stricter. As at field level, submit
                                  can be more lenient than some of these
                                  patterns state. `example` is a value valid
                                  under this override. Empty when the override
                                  narrows only `allowedValues`.
                              allowedValues:
                                description: >-
                                  Allowed values for an enum / enumArray field
                                  while the conditions hold: a subset of the
                                  field's own `allowedValues`. Submit refuses a
                                  value outside it in that case. Omitted when
                                  the override does not narrow the values.
                                example:
                                  - SSN
                                type: array
                                items:
                                  type: string
                            required:
                              - conditions
                              - constraints
                            additionalProperties: false
                      required:
                        - pointer
                        - label
                        - type
                        - required
                    description: >-
                      Scalar fields each person filling this role must submit.
                      Each `pointer` is rooted at the person object
                      (un-prefixed, e.g. `/firstName`, not
                      `/ownership/persons/firstName`). Conditions on these
                      fields default to `scope: 'root'`; per-person conditional
                      applicability uses `scope: 'person'`.
                  documents:
                    type: array
                    items:
                      type: object
                      properties:
                        canonicalType:
                          type: string
                          enum:
                            - BUSINESS_REGISTRATION
                            - ARTICLES_OF_INCORPORATION
                            - TAX_CERTIFICATE
                            - OPERATING_LICENSE
                            - REGULATORY_LICENSE
                            - SHAREHOLDERS_REGISTRY
                            - DIRECTORS_REGISTRY
                            - AUTHORIZATION_TO_ACT
                            - PROOF_OF_ADDRESS
                            - CERTIFICATE_OF_GOOD_STANDING
                            - FLOW_OF_FUNDS
                            - AUDITED_FINANCIAL_STATEMENT
                            - BANK_STATEMENT
                            - ORG_STRUCTURE_CHART
                            - AML_AUDIT
                            - COMPLIANCE_POLICY
                            - INSTITUTIONAL_INVESTOR_DOCUMENTATION
                            - IDENTITY_VERIFICATION
                            - IDENTITY_VERIFICATION_ATTESTATION
                            - EDD_EVIDENCE
                            - BANK_VERIFICATION_LETTER
                            - INVOICE
                            - CONTRACT
                            - PAYROLL_REGISTER
                            - INVESTMENT_AGREEMENT
                            - OTHER
                          description: >-
                            Canonical category label for this document slot.
                            Collect a document matching the title or category
                            and upload it with `POST /v2/documents`. Setting
                            that upload's optional `type` to this value records
                            the file against this slot; Conduit still identifies
                            the document itself, and that determination is what
                            applies.
                        title:
                          type: string
                          description: Human-readable artifact name for UI display
                          example: Government-issued photo ID
                        optional:
                          description: >-
                            True when collection is recommended but not required
                            for submission.
                          type: boolean
                      required:
                        - canonicalType
                        - title
                      additionalProperties: false
                    description: >-
                      Documents each person in this role must supply. Upload via
                      POST /v2/documents and reference the returned id under
                      `ownership.persons[i].documentIds[]`.
                required:
                  - role
                  - minCount
                  - fields
                  - documents
              - type: object
                properties:
                  role:
                    type: string
                    description: >-
                      Role label for this requirement row. A business row
                      carries `CONTROLLING_PERSON`, `LEGAL_REPRESENTATIVE` or
                      the sentinel `any`; `BENEFICIAL_OWNER` has its own branch.
                      An individual row carries `ACCOUNT_HOLDER`, the one role
                      of an individual application. Submit a role under
                      `ownership.persons[i].roles[]` verbatim, except `any`,
                      which marks a row that applies to every declared person
                      and is rejected as a person's role at submit. Each row is
                      self-contained: `documents[]` already includes any
                      requirement authored with the sentinel role `any`, so a
                      client only needs this one row per role. An `any` row
                      appears only when a rule asks for `any` as a person
                      requirement.
                    example: CONTROLLING_PERSON
                  minCount:
                    type: integer
                    minimum: 1
                    maximum: 9007199254740991
                    description: Minimum number of persons that must fill this role
                  maxCount:
                    description: >-
                      Maximum number of persons accepted under this role. Absent
                      when unbounded.
                    type: integer
                    minimum: -9007199254740991
                    maximum: 9007199254740991
                  fields:
                    type: array
                    items:
                      type: object
                      properties:
                        pointer:
                          type: string
                          description: >-
                            RFC 6901 JSON Pointer to the field in the submission
                            payload. Always starts with /. Array indices appear
                            as integers.
                          example: /businessInfo/taxId
                        label:
                          type: string
                          description: Human-readable label for display
                          example: Tax Identification Number
                        helpText:
                          description: >-
                            One-line guidance for the field, intended to render
                            as a tooltip / info pill next to the label. Plain
                            text, no markup. For `businessInfo.taxId` and
                            `businessInfo.businessEntityId` this is the
                            country-specific identifier description from
                            `countries.json` (with the issuing authority
                            prefixed when known, e.g. 'Issued by HMRC.'). For
                            other fields it is universal copy from the
                            server-side field registry. Silently absent when
                            neither source has guidance on file. See
                            api-conventions §5.1.5.
                          example: >-
                            Issued by HMRC. 10-digit number; auto-assigned on CT
                            registration; appears on HMRC correspondence. VAT
                            Registration Number (GB + 9 digits; XI prefix for
                            NI–EU trade) is supplementary — collect separately
                            if VAT-registered.
                          type: string
                        type:
                          type: string
                          enum:
                            - string
                            - number
                            - integer
                            - boolean
                            - date
                            - datetime
                            - email
                            - url
                            - phone
                            - country
                            - enum
                            - stringArray
                            - enumArray
                          description: Data type of the field
                          example: string
                        required:
                          type: boolean
                          description: Whether the field is required at submit
                        group:
                          description: >-
                            Section grouping code for renderers. Stable
                            camelCase token drawn from a closed set per
                            discovery context (onboarding today: `businessInfo`,
                            `companyClassification`, `registeredAddress`,
                            `operatingAddress`, `businessActivity`, `activity`,
                            `regulatoryHistory`, `certification`,
                            `customAnswers`; `activity` carries an individual
                            subject's own activity envelope, where
                            `businessActivity` carries a business subject's;
                            `customAnswers` carries operator-authored
                            questions). Omitted on top-level scalars without a
                            section and on fields nested inside
                            `individualRequirements[].fields[]` (already a
                            logical group). Presentation metadata; submit
                            ignores it.
                          type: string
                        mustEqual:
                          description: >-
                            Required-with-const marker. Submit enforces strict
                            equality on the field value (not just presence).
                            Most common case: legal-certification booleans
                            (`certification.termsAndConditions: { required:
                            true, mustEqual: true }`) where `false` submits are
                            rejected. Omitted when not constrained to a single
                            value.
                          anyOf:
                            - type: boolean
                            - type: string
                            - type: number
                        constraints:
                          description: >-
                            Per-value limits on this field alone, enforceable
                            client-side. Satisfying them does not by itself
                            clear submit: a value must also satisfy the field's
                            `allowedValues`, its `mustEqual`, and every
                            `conditionalOverride` whose conditions hold. Some
                            `pattern` values state only a canonical spelling,
                            and submit can accept equivalent spellings such a
                            pattern does not list.
                          type: object
                          properties:
                            pattern:
                              description: >-
                                Regex stating the canonical form of the value. A
                                value that matches it is in the form submit
                                expects; for some fields, submit is more lenient
                                than this pattern and can accept spellings it
                                does not state, so a value outside it is not
                                always refused.
                              example: ^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$
                              type: string
                            example:
                              description: Example value matching the pattern
                              example: 12.345.678/0001-95
                              type: string
                            format:
                              description: >-
                                Advertised server-enforced semantic format
                                marker. Closed enum: `safeString` (structured
                                short fields — rejects control characters, HTML
                                tags, and punctuation outside the documented
                                allowlist), `prose` (free-text fields — allows
                                ordinary punctuation and multi-line text,
                                rejecting control characters, invisible-format
                                characters, line/paragraph separators, and lone
                                surrogates) or `ip` (an IPv4 or IPv6 address —
                                no zone identifier, no leading zeros in IPv4
                                octets). The server enforces the rule at submit;
                                the marker advertises it so clients can
                                pre-validate. Arbitrary regex aliases belong in
                                `pattern`.
                              type: string
                              enum:
                                - safeString
                                - prose
                                - ip
                            minLength:
                              description: Minimum string length
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            maxLength:
                              description: Maximum string length
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            min:
                              description: Minimum numeric value
                              type: number
                            max:
                              description: Maximum numeric value
                              type: number
                            minDate:
                              description: >-
                                Earliest allowed date as ISO 8601 (YYYY-MM-DD)
                                or the literal 'today'
                              example: '1800-01-01'
                              type: string
                            maxDate:
                              description: >-
                                Latest allowed date as ISO 8601 (YYYY-MM-DD) or
                                the literal 'today'
                              example: today
                              type: string
                            maxDateTime:
                              description: >-
                                Latest allowed instant for a datetime field: the
                                literal 'now'. A value up to five minutes ahead
                                of the server clock is accepted to absorb clock
                                skew.
                              example: now
                              type: string
                              enum:
                                - now
                            minAgeYears:
                              description: >-
                                Minimum age in years (for date-of-birth-style
                                fields)
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            maxAgeYears:
                              description: >-
                                Maximum age in years (for date-of-birth-style
                                fields)
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            checksum:
                              description: >-
                                A check digit rule the value must pass beyond
                                `pattern`: `aba` for a US routing number, `iban`
                                for an international bank account number
                                (mod-97).
                              type: string
                              enum:
                                - aba
                                - iban
                          additionalProperties: false
                        conditions:
                          description: >-
                            Conditional applicability rules. The field applies
                            (is shown / required) only when every condition
                            evaluates true against the current submission. Empty
                            / absent means unconditional.
                          type: array
                          items:
                            type: object
                            properties:
                              pointer:
                                type: string
                                description: >-
                                  RFC 6901 JSON Pointer to the submitted-data
                                  field this condition reads. Resolution is
                                  governed by the sibling scope (root by
                                  default; person-scoped when scope='person').
                                example: /companyClassification/legalStructure
                              operator:
                                type: string
                                enum:
                                  - eq
                                  - in
                                  - not_in
                                  - exists
                                  - is_true
                                  - is_false
                                description: >-
                                  Comparison operator. The field is required /
                                  applies only when the condition evaluates true
                                  against the current submitted data.
                                example: eq
                              value:
                                description: >-
                                  Single comparison value, used with eq / exists
                                  operators
                                type: string
                              values:
                                description: >-
                                  Array of comparison values, used with in /
                                  not_in operators
                                type: array
                                items:
                                  type: string
                              scope:
                                description: >-
                                  Evaluation scope for `pointer`. Default `root`
                                  evaluates against the top-level submission;
                                  `person` evaluates against the current
                                  `ownership.persons[i]` row (used inside
                                  `individualRequirements[].fields[].conditions`).
                                type: string
                                enum:
                                  - root
                                  - person
                            required:
                              - pointer
                              - operator
                            additionalProperties: false
                        allowedValues:
                          description: >-
                            Allowed values for enum / enumArray fields. The
                            submitted value MUST be one of these.
                          example:
                            - LLC
                            - CORPORATION
                            - PARTNERSHIP
                          type: array
                          items:
                            type: string
                        options:
                          description: >-
                            Structured per-option metadata for enum fields with
                            display / grouping hints (label, abbr, description,
                            category). `value` mirrors an entry in
                            `allowedValues`. Present when the projector has
                            localized data to surface (e.g. country-specific
                            legal structures); enum fields without rich metadata
                            use `allowedValues` alone.
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                description: >-
                                  Submitted value. Must be one of the entries in
                                  the sibling `allowedValues` array.
                                example: Sociedad Anónima
                              label:
                                type: string
                                description: Human-readable label for display
                                example: Sociedad Anónima
                              abbr:
                                type: string
                                description: Short-form / acronym for the option
                                example: S.A.
                                nullable: true
                              description:
                                description: Long-form description of the option
                                type: string
                              category:
                                type: string
                                enum:
                                  - Corp
                                  - LLC
                                  - Sole Proprietorship
                                  - Partnership
                                  - Other
                                  - regulatory_review
                                description: >-
                                  Out-of-band metadata for an option that
                                  affects how it should be rendered or handled.
                                  Values: the legal-structure canonical bucket
                                  (`Corp` / `LLC` / `Sole Proprietorship` /
                                  `Partnership` / `Other`) — used to map the
                                  localised `value` to a standardised type; and
                                  `regulatory_review` — indicates this option is
                                  subject to additional regulatory review and
                                  may warrant a pre-submission warning to the
                                  user. Silently absent on options that carry no
                                  such metadata.
                            required:
                              - value
                              - label
                            additionalProperties: false
                        conditionalOverrides:
                          description: >-
                            Extra constraints that apply only while their own
                            conditions hold. Each element carries a `conditions`
                            array read exactly like the field's own `conditions`
                            — every condition must hold, and `scope: 'person'`
                            resolves the pointer against the current
                            `ownership.persons[i]` row — plus the `constraints`
                            submit adds for that case. Three cases ship. An
                            address states what submit keys on that address's
                            own country: a person's `/address/state` carries the
                            US subdivision pattern and `/address/postalCode` the
                            US ZIP pattern while that same person's
                            `/address/country` is `USA` (`scope: 'person'`), and
                            the business's `/operatingAddress/state` and
                            `/operatingAddress/postalCode` carry the same two
                            while `/operatingAddress/country` is `USA`, read at
                            the root of the body because the condition names no
                            scope. A person's `/taxIdNumber` carries the US
                            Social Security Number pattern while that same
                            person's `/taxIdType` is `SSN`. When two or more
                            requirement rules declare one field and a rule's
                            check depends on a condition discovery cannot settle
                            (most often a `scope: 'person'` condition), that
                            rule's check is an element too: its `constraints`
                            and, for an enum field, its `allowedValues`. Some
                            overrides' `pattern` states only the canonical value
                            to send, not the full set submit accepts: the US
                            subdivision pattern states the two-letter code with
                            or without the `US-` prefix, while submit also
                            accepts the full state name and other spellings.
                            Apply every element whose conditions hold ON TOP OF
                            the field's own `constraints`, never in place of
                            them: the value must match the field-level `pattern`
                            and every override `pattern` that applies, and a
                            bound named twice tightens to the stricter value.
                            The property is additive and a client may ignore it,
                            in which case the field reads exactly as it did
                            before the property existed and submit can still
                            reject a value the override would have named.
                            Silently absent when the field carries no
                            conditional case.
                          type: array
                          items:
                            type: object
                            properties:
                              conditions:
                                type: array
                                items:
                                  type: object
                                  properties:
                                    pointer:
                                      type: string
                                      description: >-
                                        RFC 6901 JSON Pointer to the
                                        submitted-data field this condition
                                        reads. Resolution is governed by the
                                        sibling scope (root by default;
                                        person-scoped when scope='person').
                                      example: /companyClassification/legalStructure
                                    operator:
                                      type: string
                                      enum:
                                        - eq
                                        - in
                                        - not_in
                                        - exists
                                        - is_true
                                        - is_false
                                      description: >-
                                        Comparison operator. The field is
                                        required / applies only when the
                                        condition evaluates true against the
                                        current submitted data.
                                      example: eq
                                    value:
                                      description: >-
                                        Single comparison value, used with eq /
                                        exists operators
                                      type: string
                                    values:
                                      description: >-
                                        Array of comparison values, used with in
                                        / not_in operators
                                      type: array
                                      items:
                                        type: string
                                    scope:
                                      description: >-
                                        Evaluation scope for `pointer`. Default
                                        `root` evaluates against the top-level
                                        submission; `person` evaluates against
                                        the current `ownership.persons[i]` row
                                        (used inside
                                        `individualRequirements[].fields[].conditions`).
                                      type: string
                                      enum:
                                        - root
                                        - person
                                  required:
                                    - pointer
                                    - operator
                                  additionalProperties: false
                                description: >-
                                  Conditions that must ALL hold for this
                                  override to apply. Same shape and evaluation
                                  as `conditions` on the field itself, `scope`
                                  included.
                              constraints:
                                type: object
                                properties:
                                  pattern:
                                    description: >-
                                      Regex stating the canonical form of the
                                      value. A value that matches it is in the
                                      form submit expects; for some fields,
                                      submit is more lenient than this pattern
                                      and can accept spellings it does not
                                      state, so a value outside it is not always
                                      refused.
                                    example: ^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$
                                    type: string
                                  example:
                                    description: Example value matching the pattern
                                    example: 12.345.678/0001-95
                                    type: string
                                  format:
                                    description: >-
                                      Advertised server-enforced semantic format
                                      marker. Closed enum: `safeString`
                                      (structured short fields — rejects control
                                      characters, HTML tags, and punctuation
                                      outside the documented allowlist), `prose`
                                      (free-text fields — allows ordinary
                                      punctuation and multi-line text, rejecting
                                      control characters, invisible-format
                                      characters, line/paragraph separators, and
                                      lone surrogates) or `ip` (an IPv4 or IPv6
                                      address — no zone identifier, no leading
                                      zeros in IPv4 octets). The server enforces
                                      the rule at submit; the marker advertises
                                      it so clients can pre-validate. Arbitrary
                                      regex aliases belong in `pattern`.
                                    type: string
                                    enum:
                                      - safeString
                                      - prose
                                      - ip
                                  minLength:
                                    description: Minimum string length
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  maxLength:
                                    description: Maximum string length
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  min:
                                    description: Minimum numeric value
                                    type: number
                                  max:
                                    description: Maximum numeric value
                                    type: number
                                  minDate:
                                    description: >-
                                      Earliest allowed date as ISO 8601
                                      (YYYY-MM-DD) or the literal 'today'
                                    example: '1800-01-01'
                                    type: string
                                  maxDate:
                                    description: >-
                                      Latest allowed date as ISO 8601
                                      (YYYY-MM-DD) or the literal 'today'
                                    example: today
                                    type: string
                                  maxDateTime:
                                    description: >-
                                      Latest allowed instant for a datetime
                                      field: the literal 'now'. A value up to
                                      five minutes ahead of the server clock is
                                      accepted to absorb clock skew.
                                    example: now
                                    type: string
                                    enum:
                                      - now
                                  minAgeYears:
                                    description: >-
                                      Minimum age in years (for
                                      date-of-birth-style fields)
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  maxAgeYears:
                                    description: >-
                                      Maximum age in years (for
                                      date-of-birth-style fields)
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  checksum:
                                    description: >-
                                      A check digit rule the value must pass
                                      beyond `pattern`: `aba` for a US routing
                                      number, `iban` for an international bank
                                      account number (mod-97).
                                    type: string
                                    enum:
                                      - aba
                                      - iban
                                additionalProperties: false
                                description: >-
                                  Constraints submit adds while the conditions
                                  hold. They narrow the field, never widen it,
                                  and they do not replace the field's own
                                  `constraints`: `pattern` is a SECOND regex
                                  that states the canonical form for this case,
                                  applied as well as the field-level `pattern`,
                                  and a bound named on both takes whichever
                                  value is stricter. As at field level, submit
                                  can be more lenient than some of these
                                  patterns state. `example` is a value valid
                                  under this override. Empty when the override
                                  narrows only `allowedValues`.
                              allowedValues:
                                description: >-
                                  Allowed values for an enum / enumArray field
                                  while the conditions hold: a subset of the
                                  field's own `allowedValues`. Submit refuses a
                                  value outside it in that case. Omitted when
                                  the override does not narrow the values.
                                example:
                                  - SSN
                                type: array
                                items:
                                  type: string
                            required:
                              - conditions
                              - constraints
                            additionalProperties: false
                      required:
                        - pointer
                        - label
                        - type
                        - required
                    description: >-
                      Scalar fields each person filling this role must submit.
                      Each `pointer` is rooted at the person object
                      (un-prefixed, e.g. `/firstName`, not
                      `/ownership/persons/firstName`). Conditions on these
                      fields default to `scope: 'root'`; per-person conditional
                      applicability uses `scope: 'person'`.
                  documents:
                    type: array
                    items:
                      type: object
                      properties:
                        canonicalType:
                          type: string
                          enum:
                            - BUSINESS_REGISTRATION
                            - ARTICLES_OF_INCORPORATION
                            - TAX_CERTIFICATE
                            - OPERATING_LICENSE
                            - REGULATORY_LICENSE
                            - SHAREHOLDERS_REGISTRY
                            - DIRECTORS_REGISTRY
                            - AUTHORIZATION_TO_ACT
                            - PROOF_OF_ADDRESS
                            - CERTIFICATE_OF_GOOD_STANDING
                            - FLOW_OF_FUNDS
                            - AUDITED_FINANCIAL_STATEMENT
                            - BANK_STATEMENT
                            - ORG_STRUCTURE_CHART
                            - AML_AUDIT
                            - COMPLIANCE_POLICY
                            - INSTITUTIONAL_INVESTOR_DOCUMENTATION
                            - IDENTITY_VERIFICATION
                            - IDENTITY_VERIFICATION_ATTESTATION
                            - EDD_EVIDENCE
                            - BANK_VERIFICATION_LETTER
                            - INVOICE
                            - CONTRACT
                            - PAYROLL_REGISTER
                            - INVESTMENT_AGREEMENT
                            - OTHER
                          description: >-
                            Canonical category label for this document slot.
                            Collect a document matching the title or category
                            and upload it with `POST /v2/documents`. Setting
                            that upload's optional `type` to this value records
                            the file against this slot; Conduit still identifies
                            the document itself, and that determination is what
                            applies.
                        title:
                          type: string
                          description: Human-readable artifact name for UI display
                          example: Government-issued photo ID
                        optional:
                          description: >-
                            True when collection is recommended but not required
                            for submission.
                          type: boolean
                      required:
                        - canonicalType
                        - title
                      additionalProperties: false
                    description: >-
                      Documents each person in this role must supply. Upload via
                      POST /v2/documents and reference the returned id under
                      `ownership.persons[i].documentIds[]`.
                required:
                  - role
                  - minCount
                  - fields
                  - documents
          description: >-
            Per-role count and person-level field + document requirements for
            ownership.persons[].
      required:
        - schemaVersion
        - context
        - country
        - fields
        - documents
        - minDocuments
        - individualRequirements
    ValidationErrorDto:
      type: object
      properties:
        type:
          type: string
          description: Machine-readable error code
          example: CUSTOMER_NOT_FOUND
        title:
          type: string
          description: Human-readable error type label
          example: Customer Not Found
        status:
          type: number
          description: HTTP status code
          example: 404
        detail:
          type: string
          description: Human-readable explanation of this occurrence
          example: Customer with id cus_034A0gCCVsxdV2PjHLx9k1 not found
        resolution:
          type: string
          description: What the developer should do to resolve this error
          example: >-
            Verify the customer ID. Check you are using the correct API key for
            this organization.
        docs:
          type: string
          description: URL to error documentation
          example: https://conduit-v2.mintlify.app/errors#customer-not-found
        instance:
          type: string
          description: Request path that produced the error
          example: /v2/customers/cus_034A0gCCVsxdV2PjHLx9k1
        correlationId:
          description: Request correlation ID
          example: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
          type: string
        timestamp:
          type: string
          description: ISO 8601 UTC timestamp
          example: '2026-04-27T20:00:00.000Z'
        details:
          description: >-
            Additional structured data for domain-specific errors (e.g. missing
            field lists, pair info)
        errors:
          type: array
          items:
            type: object
            properties:
              pointer:
                type: string
                description: JSON pointer to the invalid field
                example: /email
              detail:
                type: string
                description: What is wrong with this field
                example: Invalid email format
              allowedValues:
                description: The values this field accepts, when it is a closed set
                example:
                  - ach
                  - fedwire
                  - rtp
                type: array
                items:
                  type: string
              category:
                description: >-
                  Class of blocker (requirements-validator output only). 'field'
                  = form-field gap, 'document' = missing or insufficient
                  document (including per-UBO document slots), 'individual' =
                  required person missing.
                example: field
                type: string
                enum:
                  - field
                  - document
                  - individual
            required:
              - pointer
              - detail
      required:
        - type
        - title
        - status
        - detail
        - resolution
        - docs
        - instance
        - timestamp
    ProblemDetailDto:
      type: object
      properties:
        type:
          type: string
          description: Machine-readable error code
          example: CUSTOMER_NOT_FOUND
        title:
          type: string
          description: Human-readable error type label
          example: Customer Not Found
        status:
          type: number
          description: HTTP status code
          example: 404
        detail:
          type: string
          description: Human-readable explanation of this occurrence
          example: Customer with id cus_034A0gCCVsxdV2PjHLx9k1 not found
        resolution:
          type: string
          description: What the developer should do to resolve this error
          example: >-
            Verify the customer ID. Check you are using the correct API key for
            this organization.
        docs:
          type: string
          description: URL to error documentation
          example: https://conduit-v2.mintlify.app/errors#customer-not-found
        instance:
          type: string
          description: Request path that produced the error
          example: /v2/customers/cus_034A0gCCVsxdV2PjHLx9k1
        correlationId:
          description: Request correlation ID
          example: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
          type: string
        timestamp:
          type: string
          description: ISO 8601 UTC timestamp
          example: '2026-04-27T20:00:00.000Z'
        details:
          description: >-
            Additional structured data for domain-specific errors (e.g. missing
            field lists, pair info)
      required:
        - type
        - title
        - status
        - detail
        - resolution
        - docs
        - instance
        - timestamp
    RateLimitedErrorDto:
      type: object
      properties:
        type:
          type: string
          description: Machine-readable error code
          example: CUSTOMER_NOT_FOUND
        title:
          type: string
          description: Human-readable error type label
          example: Customer Not Found
        status:
          type: number
          description: HTTP status code
          example: 404
        detail:
          type: string
          description: Human-readable explanation of this occurrence
          example: Customer with id cus_034A0gCCVsxdV2PjHLx9k1 not found
        resolution:
          type: string
          description: What the developer should do to resolve this error
          example: >-
            Verify the customer ID. Check you are using the correct API key for
            this organization.
        docs:
          type: string
          description: URL to error documentation
          example: https://conduit-v2.mintlify.app/errors#customer-not-found
        instance:
          type: string
          description: Request path that produced the error
          example: /v2/customers/cus_034A0gCCVsxdV2PjHLx9k1
        correlationId:
          description: Request correlation ID
          example: 00469ea4-52c1-4ffa-bd05-9f28b236a5fe
          type: string
        timestamp:
          type: string
          description: ISO 8601 UTC timestamp
          example: '2026-04-27T20:00:00.000Z'
        details:
          description: >-
            Additional structured data for domain-specific errors (e.g. missing
            field lists, pair info)
        retryAfterSeconds:
          type: integer
          minimum: 0
          exclusiveMinimum: true
          maximum: 9007199254740991
          description: Seconds to wait before retrying
          example: 3
      required:
        - type
        - title
        - status
        - detail
        - resolution
        - docs
        - instance
        - timestamp
        - retryAfterSeconds
  securitySchemes:
    api-key:
      type: apiKey
      in: header
      name: x-api-key

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.