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

# Read code paths for one discriminator field mapping.

> Read the strand-sourced code paths for one field-mapping row in a selected discriminator projection. The row is addressed by its engine-derived group id so compact code-path artifacts can be joined without a coordinate guess.



## OpenAPI

````yaml /api-reference/bundled.yaml get /v0/experimental/component/{id}/discriminator_code_paths
openapi: 3.1.0
info:
  title: Gable API
  description: >
    API to interact with the Gable platform

    ## Authorization

    All API requests require an API key to be passed in the `X-API-KEY` header.
    For instructions on finding your API key and api endpoint check out the [API
    Key documentation](../docs/api-keys.md).

    Example: `curl -H "X-API-KEY: <your-api-key>"
    https://api-{organization}.gable.ai/v0/ping`
  contact:
    name: Gable Engineering
    url: https://gable.ai
    email: engineers@gable.ai
  version: 1.54.0
servers:
  - url: https://{hostname}.gable.ai
    description: Gable API
    variables:
      hostname:
        default: demo-api
        description: Customer environment assigned by Gable
security:
  - ApiKeyAuth: []
tags:
  - name: action
  - name: api-keys
  - name: auth
  - name: changelog
  - name: config
  - name: debug
  - name: settings
  - name: slack
  - name: sso
  - name: webhook
  - name: notifications
  - name: telemetry
  - name: component
  - name: components
  - name: sca
  - name: cross-service-components
  - name: lineage
  - name: events
  - name: measurements
  - name: defect-report
  - name: data-tagging
    description: Tag vocabulary management and field level tagging of lineage boundaries.
paths:
  /v0/experimental/component/{id}/discriminator_code_paths:
    get:
      tags:
        - lineage
      summary: Read code paths for one discriminator field mapping.
      description: >-
        Read the strand-sourced code paths for one field-mapping row in a
        selected discriminator projection. The row is addressed by its
        engine-derived group id so compact code-path artifacts can be joined
        without a coordinate guess.
      operationId: getExperimentalComponentDiscriminatorCodePaths
      parameters:
        - in: path
          name: id
          required: true
          schema:
            type: string
            format: uuid
          description: UUID of the component.
        - in: query
          name: versionId
          required: true
          schema:
            type: string
          description: Exact scan/version containing the field-mapping row.
        - in: query
          name: fieldMappingGroupId
          required: true
          schema:
            $ref: '#/components/schemas/DiscriminatorGroupId'
          description: Engine-derived identity of the field-mapping row.
        - in: query
          name: viewTime
          required: false
          schema:
            type: string
            format: uuid
          description: >-
            Optional UUIDv7 event-time cutoff. Keeps a lazy row read in the same
            historical world as the component page that requested it.
      responses:
        '200':
          description: The selected row's code paths and deduplicated anchor pool.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DiscriminatorCodePathsResponse'
        '400':
          description: Missing or invalid parameter.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: Component, version, or field-mapping row not found.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Internal Server Error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    DiscriminatorGroupId:
      type: string
      description: Discriminator group ID from the discriminated engine
      pattern: ^[0-9a-f]{16}$
      example: 0a1b2c3d4e5f6070
    DiscriminatorCodePathsResponse:
      type: object
      description: >-
        Code paths for one discriminator field-mapping row. The row keeps one
        path per contributing strand, and every path references the deduplicated
        anchor pool by content-addressed id.
      properties:
        fieldMappingGroupId:
          $ref: '#/components/schemas/DiscriminatorGroupId'
        codePaths:
          type: array
          items:
            $ref: '#/components/schemas/DiscriminatorRowCodePath'
        anchors:
          type: array
          items:
            $ref: '#/components/schemas/CodeAnchor'
      required:
        - fieldMappingGroupId
        - codePaths
        - anchors
      additionalProperties: false
    ErrorResponse:
      type: object
      required:
        - message
      properties:
        id:
          type: number
        title:
          type: string
        message:
          type: string
    DiscriminatorRowCodePath:
      type: object
      description: >-
        One code path for a field mapping — the ordered steps of a single strand
        the engine grouped into it.
      properties:
        anchorIds:
          type: array
          description: >-
            The path's anchors in step order, each an `anchorId` in the
            response's top-level `anchors` pool.
          items:
            type: string
      required:
        - anchorIds
      additionalProperties: false
    CodeAnchor:
      type: object
      properties:
        anchorId:
          type: string
          description: Unique identifier for the anchor.
        name:
          type: string
          description: Human readable name of the code anchor.
        codeUri:
          $ref: '#/components/schemas/CodeURI'
        url:
          type: string
          description: URL to the code anchor.
        kind:
          $ref: '#/components/schemas/StrandEdgeKind'
        description:
          type: string
          description: >
            Prime-emitted human-readable description of the step (e.g. "Field
            'email'

            read from 'AuthenticationRequest'"). Emitted by sca-prime for every
            strand

            step regardless of kind; absent on legacy DDB-sourced anchors that
            predate

            the strand read path.
        transform:
          type: string
          description: >
            sca-prime's transform mechanism for the call at this step — what the
            call

            does to the value rather than where it flows. Current vocabulary:

            `reformat`, `calculation`, `aggregation`, `encryption`,
            `decryption`,

            `hashing`, `redaction`.


            Intentionally an open string rather than an enum: sca-prime
            documents the

            vocabulary as growable and requires consumers to tolerate values
            they do

            not recognize, so an enum here would reject otherwise-valid scans
            the day

            Prime adds a mechanism. Absent when the step's call carries no
            transform

            tag, and on legacy DDB-sourced anchors.
        containingFunction:
          type: string
          description: >
            Fully-qualified name of the function whose body contains this step —
            the

            enclosing function, not the callee named in `description`. sca-prime

            emits it as a METHOD node id on the strand-sourced code-paths file;
            the

            read resolves that id against the run's strand metadata index.

            Best-effort: absent for steps in external, unparsed, or synthetic

            functions, when the metadata index is unavailable, and on legacy

            DDB-sourced anchors.
      required:
        - anchorId
        - name
        - codeUri
    CodeURI:
      type: object
      description: >-
        Code URI is a unique identifier for a code location. It is used to
        identify the code location in the codebase.
      properties:
        file:
          type: string
          description: Relative file path in the repo.
        lineStart:
          type: integer
        lineEnd:
          type: integer
        columnStart:
          type: integer
        columnEnd:
          type: integer
      required:
        - file
        - lineStart
        - columnStart
    StrandEdgeKind:
      type: string
      description: >
        Prime-emitted per-step operation kind on a strand.path[] entry.
        Named-kind

        steps (field_read / field_write / function_call / return) carry a

        human-readable description; unnamed kinds (flow / assignment / unknown)
        do

        not. Mirrors sca-prime's strand vocabulary.
      enum:
        - field_read
        - field_write
        - function_call
        - return
        - flow
        - assignment
        - unknown
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-API-KEY

````

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