> ## 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.

# Export a component's lineage

> Export one component's discriminator lineage for a run: the same payload groups, field mapping rows, tags and strand edges the component details page reads, plus the components one strand edge away. Code steps are omitted unless `includeCodeAnchors` is true.



## OpenAPI

````yaml /api-reference/bundled.yaml get /v0/lineage/component-export
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/lineage/component-export:
    get:
      tags:
        - lineage
      summary: Export a component's lineage
      description: >-
        Export one component's discriminator lineage for a run: the same payload
        groups, field mapping rows, tags and strand edges the component details
        page reads, plus the components one strand edge away. Code steps are
        omitted unless `includeCodeAnchors` is true.
      operationId: getLineageComponentExport
      parameters:
        - in: query
          name: run_id
          schema:
            type: string
            format: uuid
          required: true
          description: UUID of the run (the scan version) to export.
        - in: query
          name: includeCodeAnchors
          schema:
            type: boolean
            default: false
          required: false
          description: >-
            When true, every field mapping row carries its code paths and the
            response carries the deduplicated anchor pool.
      responses:
        '200':
          description: The component's lineage export
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/LineageComponentExportResponse'
        '400':
          description: Client error response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: >-
            Forbidden - export API unavailable or namespace filtering denied
            access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: Run not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Error exporting lineage
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    LineageComponentExportResponse:
      type: object
      properties:
        timestamp:
          type: string
          format: date-time
        runId:
          type: string
          format: uuid
        lineage:
          $ref: '#/components/schemas/DiscriminatorDataReadResponse'
        connectedComponents:
          type: array
          description: >-
            Components on the other end of a non-deleted strand edge from the
            exported component.
          items:
            $ref: '#/components/schemas/LineageExportConnectedComponent'
      required:
        - timestamp
        - runId
        - lineage
        - connectedComponents
      additionalProperties: false
    ErrorResponse:
      type: object
      required:
        - message
      properties:
        id:
          type: number
        title:
          type: string
        message:
          type: string
    DiscriminatorDataReadResponse:
      description: >-
        Response for the discriminator data read operation. The `lineageMode`
        property  selects the variant: NO_STRAND_DATA (no data) or DISCRIMINATOR
        (roll-up rows).
      oneOf:
        - $ref: '#/components/schemas/NoStrandDataResponse'
        - $ref: '#/components/schemas/DiscriminatorDataResponse'
      discriminator:
        propertyName: lineageMode
        mapping:
          NO_STRAND_DATA: '#/components/schemas/NoStrandDataResponse'
          DISCRIMINATOR: '#/components/schemas/DiscriminatorDataResponse'
    LineageExportConnectedComponent:
      type: object
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        namespace:
          type: string
        type:
          type: string
          enum:
            - CODE
            - DATA_STORE
        direction:
          type: string
          enum:
            - UPSTREAM
            - DOWNSTREAM
            - BOTH
          description: Which side of the exported component this component sits on.
        schema:
          $ref: '#/components/schemas/DiscriminatorGraphDataStoreSchema'
      required:
        - id
        - name
        - type
        - direction
      additionalProperties: false
    NoStrandDataResponse:
      type: object
      description: Returned when the selected scan carries no strand data
      properties:
        lineageMode:
          type: string
          enum:
            - NO_STRAND_DATA
          description: Always NO_STRAND_DATA for this variant (union discriminator).
        selectedVersionId:
          type: string
          description: The scan/version that was selected and found to lack strands.
        component:
          $ref: '#/components/schemas/DiscriminatorComponentInfo'
          description: >-
            Header-level component identity. Present only when the request opted
            in with `include=component`.
      required:
        - lineageMode
        - selectedVersionId
      additionalProperties: false
    DiscriminatorDataResponse:
      type: object
      description: Returned discriminated data for a strands-backed scan
      properties:
        lineageMode:
          type: string
          enum:
            - DISCRIMINATOR
          description: Always DISCRIMINATOR for this variant (union discriminator).
        selectedVersionId:
          type: string
          description: The selected scan/version whose roll-up produced these rows.
        approval:
          $ref: '#/components/schemas/ProjectionApproval'
          description: >-
            Approval state folded for selectedVersionId. This is the authority
            for the selected discriminator projection; version-list rows do not
            carry approval state.
        engineVersion:
          type: string
          description: Discriminator engine version that produced the roll-up
        discriminatorData:
          type: array
          items:
            $ref: '#/components/schemas/DiscriminatorData'
        codeIngressPointCount:
          type: integer
          minimum: 0
          description: >-
            Number of distinct ingress code boundaries in the selected
            projection, derived from boundary-pair evidence. This is an
            aggregate only: it is not display identity or a write address, and
            payload groups without boundary-pair evidence do not contribute.
        codeEgressPointCount:
          type: integer
          minimum: 0
          description: >-
            Number of distinct egress code boundaries in the selected
            projection, derived from boundary-pair evidence. Counts every
            distinct fan-out end even when a payload group's single display
            egress is null.
        codePathRowCount:
          type: integer
          minimum: 0
          description: >-
            Number of field-mapping rows backed by at least one discriminator
            strand with code-path evidence. Derived from the lightweight path
            identity in the roll-up without loading or returning code-anchor
            details. For legacy verbose artifacts, the engine's recorded step
            count is the available evidence and may outlive an unavailable or
            unjoinable sidecar.
        payloadGroups:
          type: array
          description: >-
            The selected scan's payload groups as first-class objects, in
            roll-up order, including groups with zero field mappings.
          items:
            $ref: '#/components/schemas/DiscriminatorPayloadGroup'
        anchors:
          type: array
          description: >-
            Pool of every code anchor referenced by any row's `anchorIds`,
            deduped by the content-addressed `anchorId` so a step shared by
            several rows is carried once. Present only when the request opted in
            with `include=anchors`; empty when the scan has no strand-sourced
            code paths.
          items:
            $ref: '#/components/schemas/CodeAnchor'
        component:
          $ref: '#/components/schemas/DiscriminatorComponentInfo'
          description: >-
            Header-level component identity. Present only when the request opted
            in with `include=component`.
        edges:
          type: array
          description: >-
            Strand edges touching this component on either side, projected from
            the edge lifecycle event log against each endpoint component's
            latest scan. Present only when the request opted in with
            `include=edges`.
          items:
            $ref: '#/components/schemas/DiscriminatorProjectedEdge'
        invalidEventCount:
          type: integer
          description: >-
            Count of stored edge lifecycle events whose persisted payload could
            not be interpreted. Present only when the request opted in with
            `include=edges`.
        xgressMetadata:
          type: array
          description: >-
            xgress-level attributes (HTTP routes, data-store entities, and
            future kinds) attached to each field mapping's ingress or egress
            boundary, resolved by the discriminator engine and passed through
            here. Empty until the engine emits any attribute nodes on this scan,
            and sparse after that. Consumers join by `fieldMappingAddress` +
            `side` to the corresponding `DiscriminatorData` row — qualified by
            `payloadAddress`, since field-mapping coordinates repeat across
            payloads.
          items:
            $ref: '#/components/schemas/XgressMetadata'
      required:
        - lineageMode
        - selectedVersionId
        - approval
        - engineVersion
        - discriminatorData
        - codeIngressPointCount
        - codeEgressPointCount
        - codePathRowCount
      additionalProperties: false
    DiscriminatorGraphDataStoreSchema:
      type: object
      description: >-
        A data store component's registry schema in the graph read's
        `detailLevel=fields` mode. The strand model does not scan stores, so
        this is registry-sourced: the same field names an edge declaration's
        data-store endpoint is validated against.
      properties:
        fields:
          type: array
          items:
            type: object
            properties:
              name:
                type: string
              type:
                type: string
            required:
              - name
              - type
            additionalProperties: false
      required:
        - fields
      additionalProperties: false
    DiscriminatorComponentInfo:
      type: object
      description: >-
        Header-level identity of the component a discriminator read addresses,
        from the component registry: display names, namespace, and repository
        metadata for source links. Deliberately not the legacy component shape;
        boundaries, paths, and schemas do not travel here.
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        friendlyName:
          type: string
        namespace:
          type: string
        repoName:
          type: string
        repoUri:
          type: string
        repoUiUrl:
          type: string
        repoBranch:
          type: string
          description: >-
            The branch the selected version was scanned from, falling back to
            the registry's branch when the scan recorded none. The registry
            column is written once at component creation, so it is not the
            branch of later scans.
        projectRoot:
          type: string
          description: >-
            Path from the repository root to the analyzed project, when the
            component is not at the repo root. Code-anchor file paths are
            relative to this, so a consumer building a source link or fetching a
            snippet must prefix it. Absent for repo-root components.
        latestVersionId:
          type: string
          description: The component's newest scan/version id at read time.
      required:
        - id
        - name
      additionalProperties: false
    ProjectionApproval:
      type: object
      additionalProperties: false
      description: Approval state folded into a component projection.
      required:
        - status
      properties:
        status:
          type: string
          enum:
            - UNAPPROVED
            - APPROVED
            - APPROVED_WITH_EDITS_SINCE_APPROVAL
        approvalEventId:
          type: string
          description: Event ID of the approval currently applied to this projection.
        approvedAt:
          type: string
          format: date-time
        approvedBy:
          type: object
          additionalProperties: false
          required:
            - userId
            - email
            - name
          properties:
            userId:
              type: string
            email:
              type: string
            name:
              type: string
        note:
          type: string
    DiscriminatorData:
      type: object
      description: >-
        Discriminated field pair data: one field_mapping group with its parent
        payload group. Carries discriminator coordinate data.
      properties:
        payloadAddress:
          $ref: '#/components/schemas/DiscriminatorGroupAddress'
        fieldMappingAddress:
          $ref: '#/components/schemas/DiscriminatorGroupAddress'
        payloadGroupId:
          $ref: '#/components/schemas/DiscriminatorGroupId'
        fieldMappingGroupId:
          $ref: '#/components/schemas/DiscriminatorGroupId'
        fieldMappingKind:
          type: string
          description: The field_mapping_kind coordinate.
          enum:
            - DataFlow
            - KeyValueBridge
            - ControlFlow
        origin:
          type: string
          description: >-
            Declaration provenance for the field mapping: SCAN (engine evidence
            only), BYO_ADD (user-declared, absent from the scan), BYO_CHANGE
            (user-declared over a scan-backed group).
          enum:
            - SCAN
            - BYO_ADD
            - BYO_CHANGE
        suppressed:
          type: boolean
          description: >-
            True when the latest suppression event for this field mapping's
            exact group address is a suppression.
        payloadSuppressed:
          type: boolean
          description: >-
            True when the latest suppression event for the parent payload's
            exact group address is a suppression.
        display:
          $ref: '#/components/schemas/DiscriminatorFieldMappingDisplay'
          description: >-
            Render-only identity for this row. Always present. Everything a
            consumer shows to a user comes from here; the addresses above are
            for addressing only.
        ingressField:
          type: string
          description: >-
            Superseded by `display.ingressField`. Retained for consumers that
            have not moved yet; removed once none remain. Present when the
            grouping fact is a string.
        egressField:
          type: string
          description: >-
            Superseded by `display.egressField`. Retained for consumers that
            have not moved yet; removed once none remain. Present when the
            grouping fact is a string.
        codePaths:
          type: array
          description: >-
            This field mapping's code paths, one entry per strand the engine
            grouped into it, in roll-up order. Present only when the request
            opted in with `include=anchors`; an opted-in row whose strands
            resolve to no recorded path carries an empty array, which is a real
            answer (no evidence) rather than a missing one.

            One entry per strand rather than a single merged list: a field pair
            commonly spans several strands, and merging them would present
            unrelated traces as one sequence.
          items:
            $ref: '#/components/schemas/DiscriminatorRowCodePath'
      required:
        - payloadAddress
        - fieldMappingAddress
        - payloadGroupId
        - fieldMappingGroupId
        - origin
        - display
        - suppressed
        - payloadSuppressed
      additionalProperties: false
    DiscriminatorPayloadGroup:
      type: object
      description: >-
        One payload group of the selected scan's projection, as a first-class
        object: its group id (engine-owned for a scanned payload, derived from
        the same coordinates for a declared one), its durable coordinate address
        (the write / composition addressing vocabulary), a display label, its
        declaration origin, and its projected suppression state. A payload group
        with zero field mappings still appears here.
      properties:
        groupId:
          $ref: '#/components/schemas/DiscriminatorGroupId'
        origin:
          type: string
          description: >-
            Declaration provenance for the payload: SCAN (engine evidence only),
            BYO_ADD (user-declared, absent from the scan), BYO_CHANGE
            (user-declared over a scan-backed payload).
          enum:
            - SCAN
            - BYO_ADD
            - BYO_CHANGE
        coordinates:
          $ref: '#/components/schemas/DiscriminatorGroupCoordinates'
        display:
          $ref: '#/components/schemas/DiscriminatorPayloadDisplay'
          description: >-
            Render-only identity for this payload, sourced from the roll-up's
            boundary pair. Always present. Everything a consumer shows to a user
            comes from here; `coordinates` is for addressing only.
        displayName:
          type: string
          description: >-
            Superseded by `display.label`, which is sourced from the roll-up's
            boundary pair rather than from the group's coordinates. Retained for
            consumers that have not moved yet; removed once none remain.
        suppressed:
          type: boolean
          description: >-
            True when the latest suppression event for this payload's exact
            group address is a suppression.
        fieldTags:
          type: array
          description: >-
            Effective field tags on this payload's fields, sorted by direction
            then field path. Present only when the request opted in with
            `include=tags`; an opted-in payload with no tagged fields carries an
            empty array.
          items:
            $ref: '#/components/schemas/DiscriminatorFieldTagEntry'
        dependsOnTags:
          type: array
          description: >-
            Tags this payload's fields depend on through direct-hop lineage,
            sorted by direction then field path. Present only when the request
            opted in with `include=tags`; empty when nothing was derived.
          items:
            $ref: '#/components/schemas/DiscriminatorFieldDependsOnTagEntry'
      required:
        - groupId
        - origin
        - coordinates
        - display
        - displayName
        - suppressed
      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
    DiscriminatorProjectedEdge:
      type: object
      description: >-
        One strand edge as projected from its lifecycle events. The latest
        declaration/deletion per edge id wins; an active edge is then evaluated
        against both endpoint components' selected scans.
      properties:
        edgeId:
          type: string
          format: uuid
        state:
          type: string
          enum:
            - connected
            - pending
            - dangling
            - deleted
          description: >-
            connected — both payload addresses resolve in their roll-ups;
            pending — at least one side's selected scan carries no strands;
            dangling — both sides are readable but at least one payload address
            is absent from its roll-up; deleted — the latest lifecycle event is
            a deletion (audit channel only).
        origin:
          type: string
          enum:
            - SCANNER
            - MANUAL
          description: >-
            How the edge was declared. SCANNER edges came from immutable scanner
            attachments; MANUAL edges were declared through the BYO edge API.
        source:
          $ref: '#/components/schemas/DiscriminatorGroupAddress'
        destination:
          $ref: '#/components/schemas/DiscriminatorGroupAddress'
        fieldMappings:
          type: array
          items:
            $ref: '#/components/schemas/DiscriminatorEdgeFieldMapping'
        sourceGroupId:
          type: string
          description: Advisory payload group-id stamp from the declaration.
        destinationGroupId:
          type: string
          description: Advisory payload group-id stamp from the declaration.
        note:
          type: string
        sourceDisplay:
          $ref: '#/components/schemas/DiscriminatorEdgeEndpointDisplay'
          description: >-
            Display identity for the source endpoint. Present when the endpoint
            component's registry record was readable at projection time.
        destinationDisplay:
          $ref: '#/components/schemas/DiscriminatorEdgeEndpointDisplay'
          description: >-
            Display identity for the destination endpoint. Present when the
            endpoint component's registry record was readable at projection
            time.
      required:
        - edgeId
        - state
        - origin
        - source
        - destination
        - fieldMappings
        - sourceGroupId
        - destinationGroupId
      additionalProperties: false
    XgressMetadata:
      type: object
      description: >-
        xgress-level attributes attached to one FIELD MAPPING's ingress or
        egress boundary — the engine's union of the attribute nodes reachable
        from just that field pair's strands.


        The scope is deliberately narrow. The engine also computes this union at
        payload level, but a payload named after a framework method
        (`JdbcTemplate.query`) collects the attributes of every handler
        downstream of it — on a large scan, hundreds of routes that no single
        field pair traverses. That union describes the payload group, not
        anything a consumer renders, so it is not surfaced.


        One entry per `(fieldMappingAddress, side)`; a field mapping with
        attributes on both sides emits two. Field mappings whose boundaries
        carry no attributes are omitted entirely, so the array is sparse — a
        consumer that finds no entry for a row renders nothing rather than
        widening to the parent payload.


        `payloadAddress` is the parent, carried so consumers can qualify the
        join: field-mapping coordinates are unique only WITHIN a payload, so two
        payloads can hold field mappings with identical coordinates.
      required:
        - payloadAddress
        - fieldMappingAddress
        - side
        - attributes
      properties:
        payloadAddress:
          $ref: '#/components/schemas/DiscriminatorGroupAddress'
          description: >-
            The parent payload. Matches the `ancestors` entry on
            `fieldMappingAddress`, and the `payloadAddress` of the corresponding
            `DiscriminatorData` row.
        fieldMappingAddress:
          $ref: '#/components/schemas/DiscriminatorGroupAddress'
          description: >-
            The field mapping these attributes belong to. Joins to the
            `fieldMappingAddress` of the corresponding `DiscriminatorData` row.
        side:
          type: string
          enum:
            - ingress
            - egress
          description: Which side of the boundary these attributes describe.
        attributes:
          type: array
          description: >-
            One or more resolved attributes. An engine that emits mixed-kind
            arrays on one side is not expected in practice — the frontend
            renders defensively regardless.
          items:
            $ref: '#/components/schemas/XgressAttribute'
      additionalProperties: false
    DiscriminatorGroupAddress:
      type: object
      description: The metadata coordinates for a discriminator group
      properties:
        componentId:
          type: string
          format: uuid
          description: The component this group lives on. Must equal the route component.
        level:
          $ref: '#/components/schemas/DiscriminatorLevel'
        ancestors:
          type: array
          description: >-
            Root-to-immediate-parent ancestor chain. Empty for a `payload`;
            exactly one `payload` entry for a `field_mapping`. Every ancestor
            carries the same component and config identity as this wrapper.
          items:
            $ref: '#/components/schemas/DiscriminatorGroupAncestor'
        coordinates:
          $ref: '#/components/schemas/DiscriminatorGroupCoordinates'
      required:
        - componentId
        - level
        - ancestors
        - coordinates
      additionalProperties: false
    DiscriminatorGroupId:
      type: string
      description: Discriminator group ID from the discriminated engine
      pattern: ^[0-9a-f]{16}$
      example: 0a1b2c3d4e5f6070
    DiscriminatorFieldMappingDisplay:
      type: object
      description: >-
        Render-only identity for a field mapping row. Carries the same field
        names the row's coordinates hold, sourced as display so consumers never
        read a coordinate by key. Field names and arity here are fixed by this
        contract; coordinate dimensions are the discriminator config's and may
        change.
      properties:
        ingressField:
          description: >-
            The row's ingress field name, or null where the grouping fact is
            absent or is not a string.
          anyOf:
            - type: string
            - type: 'null'
        egressField:
          description: >-
            The row's egress field name, or null where the grouping fact is
            absent or is not a string.
          anyOf:
            - type: string
            - type: 'null'
        label:
          type: string
          description: >-
            Pre-composed label for the row, spanning both field names when
            present. Not a parseable format: a consumer that needs the ends
            separately reads `ingressField` and `egressField`.
      required:
        - ingressField
        - egressField
        - label
      additionalProperties: false
    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
    DiscriminatorGroupCoordinates:
      type: object
      description: >-
        Discriminator-group coordinates — the durable address of a group, as
        key-value pairs of the facts the group is grouped by. Keys are the
        discriminator config's group_by dimensions for the group's level,
        verbatim; the dimension vocabulary is defined by the config, not by this
        API. Values are the exact grouping facts; null is the engine's null
        coordinate (fact unknown). Edges and BYO metadata attach to lineage by
        these coordinates, never by group ID (group IDs are derived from
        coordinates by the discriminator engine and are only stable within one
        discriminator config).
      additionalProperties:
        description: >-
          A grouping fact. The engine's coordinate value algebra: null, boolean,
          integer, string, or array of strings.
        anyOf:
          - type: 'null'
          - type: boolean
          - type: integer
          - type: string
          - type: array
            items:
              type: string
    DiscriminatorPayloadDisplay:
      type: object
      description: >-
        Render-only identity for a payload group, sourced from the roll-up's
        boundary pair rather than from the group's coordinates.


        Display and coordinates are two separate vocabularies and may not be
        mixed. Display values are read by key and rendered; their field names
        and arity are fixed by this contract. Coordinates are copied verbatim
        into writes and compared as whole objects; their dimensions belong to
        the discriminator config and may change. Deriving one from the other in
        either direction is always a bug: a label parsed back into an address
        dangles, and an address rendered as a label goes stale the moment the
        config changes.
      properties:
        ingress:
          $ref: '#/components/schemas/DiscriminatorPayloadEndpoint'
          description: The ingress end of the path.
        egress:
          description: >-
            The egress end of the path, or null where the roll-up attributed no
            single egress to this payload group. Consumers detect the
            unattributed case by `egress === null` — never by inspecting
            coordinates.
          anyOf:
            - $ref: '#/components/schemas/DiscriminatorPayloadEndpoint'
            - type: 'null'
        label:
          type: string
          description: >-
            Pre-composed label for the payload, spanning both ends when `egress`
            is present and naming the ingress alone when it is null. Not a
            parseable format: a consumer that needs the ends separately reads
            `ingress` and `egress`, and one that needs an affordance for the
            unattributed case branches on `egress === null`.
      required:
        - ingress
        - egress
        - label
      additionalProperties: false
    DiscriminatorFieldTagEntry:
      type: object
      description: >-
        The effective tags on one field of the payload group carrying this
        entry, addressed the discriminator-native way: the payload group
        supplies the payload half of the address, `direction` and `fieldPath`
        the field half. Only fields the selected scan's field-mapping rows
        expose for that payload are entries here; a tag on a field the scan no
        longer carries is not rendered. Legacy boundary-addressed tags never
        appear here and discriminator-addressed tags never appear on the legacy
        component read: the two vocabularies are separate address spaces by
        design.
      properties:
        direction:
          type: string
          enum:
            - ingress
            - egress
          description: >-
            Which side of the payload the field is on: `ingress` addresses a
            row's `ingress_field` coordinate, `egress` its `egress_field`
            coordinate.
        fieldPath:
          type: string
          description: >-
            Dotted field path, exactly the row coordinate it addresses
            (`ingressField` / `egressField` on the rows of this payload group).
        tags:
          type: array
          description: >-
            Effective tags on that field, joined against the vocabulary at read
            time.
          items:
            $ref: '#/components/schemas/FieldTagRef'
      required:
        - direction
        - fieldPath
        - tags
      additionalProperties: false
    DiscriminatorFieldDependsOnTagEntry:
      type: object
      description: >-
        The tags one field of the carrying payload group depends on through
        lineage, derived per read and never writable. Direct hops only:
        `nearest_hops` is 0 for a tag reached along this component's own
        DataFlow field mappings and 1 for a tag reached across one connected
        strand edge. Deeper reachability is not computed by this read. Kept
        apart from `fieldTags` so a derived tag can never be mistaken for one
        applied to the field.
      properties:
        direction:
          type: string
          enum:
            - ingress
            - egress
        fieldPath:
          type: string
          description: Dotted field path, addressed the same way `fieldTags` entries are.
        dependsOn:
          type: array
          description: Tags reachable upstream of that field, one entry per distinct tag.
          items:
            $ref: '#/components/schemas/DependsOnTagRef'
      required:
        - direction
        - fieldPath
        - dependsOn
      additionalProperties: false
    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
    DiscriminatorEdgeFieldMapping:
      type: object
      description: >-
        One cross-service field mapping carried by an edge. Paths are
        dot-separated field paths (e.g. `order.customer.id`); a literal dot in a
        field name is not supported and is rejected as FIELD_PATH_UNSUPPORTED.
      properties:
        sourceFieldPath:
          type: string
          description: Field path on the edge's source payload.
        destinationFieldPath:
          type: string
          description: Field path on the edge's destination payload.
        notes:
          type: string
          description: Optional free-text note for this mapping.
        dataStoreEvidence:
          type: array
          description: >-
            Scanner-derived evidence describing which part of a whole
            application value the mapped data-store field contributes to. These
            entries enrich this field mapping; they do not declare additional
            discriminator fields or nested field mappings.
          items:
            type: object
            additionalProperties: false
            properties:
              derivation:
                type: string
                enum:
                  - direct
                  - computed
                  - aggregate
                  - unknown
              projectionLabel:
                type: string
                description: SQL projection or mapper label proven for this contribution.
              applicationFieldPath:
                type: string
                description: >-
                  Unambiguous path within the whole application value, when the
                  scanner can prove one.
            required:
              - derivation
      required:
        - sourceFieldPath
        - destinationFieldPath
      additionalProperties: false
    DiscriminatorEdgeEndpointDisplay:
      type: object
      description: >-
        Display identity for one strand edge endpoint: the endpoint component's
        registry name and a label for the addressed payload, derived from the
        declaration's coordinates. Carried alongside the authoritative address
        so consumers can render an edge without loading the endpoint component.
      properties:
        componentName:
          type: string
        componentType:
          type: string
          enum:
            - CODE
            - DATA_STORE
          description: >-
            Registry component class of the endpoint component: CODE for repo
            components, DATA_STORE for data-store components. A data-store
            endpoint is addressed as one payload named by the store and its
            mapped field paths are the store schema's field names.
        payloadLabel:
          type: string
          description: >-
            The endpoint payload's `payload_name` coordinate when present,
            otherwise the coordinate values joined in key order.
      required:
        - componentName
        - componentType
        - payloadLabel
      additionalProperties: false
    XgressAttribute:
      type: object
      description: >-
        A single xgress-level fact resolved by the discriminator engine from a
        metadata node referenced by an ingress/egress boundary — an HTTP route
        on an API handler, a data-store entity on a data-access site, and so on.


        The `kind` discriminator is a free-form string (not an enum) so additive
        engine vocabulary changes do not reject otherwise-valid responses.
        Consumers narrow on `kind` and render defensively.


        Kinds the engine emits, as of sca-prime v1.2.21+:


        - `api_route` — `{method, path}`

        - `data_store_operation` — `{operation, resources[{entity}]}`;
        `operation` is
          `read` / `write` / `unknown`

        - `data_store_field_provenance` — `{derivation, projection_label?,
          sources[{table, column}]}`; where an ingress value was read from

        - `data_store_field_destination` — `{derivation, targets[{table,
        column}]}`;
          where an egress value is written

        - `data_store_context` — `{provider, technology, namespace?}`

        - `resource_operation` — `{operation, resources[{kind, name}]}`;
        non-database
          boundaries (Kafka topics, files, cloud objects)

        - `data_store_entity` — `{entity}`. NOT deprecated and NOT renamed: it
        is a
          live variant in the producer and every scan predating v1.2.21 carries it,
          so consumers must keep handling it indefinitely. It proves no access
          direction, unlike `data_store_operation`.
      required:
        - kind
      properties:
        kind:
          type: string
          description: >-
            Attribute kind. Known values: `api_route` (with `method` and
            `path`), `data_store_entity` (with `entity`).
      additionalProperties: true
    DiscriminatorLevel:
      type: string
      description: >-
        A level in the product_canonical group hierarchy. `payload` is the root
        level; `field_mapping` is its child. The group_by dimensions for each
        level are defined by the config, not enumerated by this API (see
        DiscriminatorGroupCoordinates).
      enum:
        - payload
        - field_mapping
    DiscriminatorGroupAncestor:
      type: object
      description: >-
        One ancestor group in a canonical address chain. Ancestors are ordered
        root-to-immediate-parent: a `field_mapping` carries its `payload`, and a
        `payload` carries none. The chain's depth and each level's coordinate
        dimensions are the discriminator config's, not this API's — copy an
        ancestor's coordinates verbatim rather than rebuilding them. The service
        derives the parent chain from these coordinates; clients never supply an
        authoritative parent group ID.
      properties:
        level:
          $ref: '#/components/schemas/DiscriminatorLevel'
        coordinates:
          $ref: '#/components/schemas/DiscriminatorGroupCoordinates'
      required:
        - level
        - coordinates
      additionalProperties: false
    DiscriminatorPayloadEndpoint:
      type: object
      description: >-
        Display identity for one end of a payload path, lifted from the
        roll-up's strand provenance. Render-only: an endpoint is not an address,
        is not guaranteed unique, and must never be parsed back into coordinates
        or copied into a write.
      properties:
        name:
          type: string
          description: >-
            Short form of `qualifiedName` for dense UI — the segment after the
            last `.` when the name is dotted, otherwise the whole name.
        qualifiedName:
          type: string
          description: >-
            The engine boundary name, in the roll-up's start_name/end_name
            vocabulary (often a fully qualified class or callee name). This is
            the same vocabulary the explorer's `boundary:{side}:{name}` trace id
            is built from.
        site:
          type: string
          description: >-
            Unambiguous source site shared by the strands represented at this
            end of the payload group, as emitted by strand provenance. Omitted
            when the group contains no source site or contains several distinct
            sites. This value is render-only and never participates in
            discriminator addressing.
      required:
        - name
        - qualifiedName
      additionalProperties: false
    FieldTagRef:
      type: object
      description: >-
        One tag as it renders on one field, joined against the vocabulary at
        read time. Removed tags and deleted definitions are absent; a
        deactivated definition still renders on fields already carrying it.
      properties:
        tag_id:
          type: string
          description: The definition this refers to, and the id to send back on a REMOVE.
        name:
          type: string
          description: Display name, resolved from the definition on this read.
        kind:
          $ref: '#/components/schemas/TagKind'
        source:
          type: string
          description: >-
            `user` is a person, the CLI or an API key; `system` is the ingest
            detector; most recent wins. A tag renders only on the field it was
            applied to, so every rendered tag is removable on that field.
          enum:
            - system
            - user
        color:
          type: string
          description: Display color, resolved from the definition.
        detection_category:
          type: string
          description: >-
            Which detector pattern fired, for `source: system` only. An opaque
            label, not an enum, so new detectors widen the values.
      required:
        - tag_id
        - name
        - kind
        - source
      additionalProperties: false
    DependsOnTagRef:
      type: object
      description: >-
        One tag that a field depends on through lineage, rather than carrying
        itself. Derived per read by walking downstream from every directly
        tagged field, never stored and never writable. The original tag is not
        copied: a field whose upstream is `pii` depends on `pii`, it is not
        itself `pii`.
      properties:
        tag_id:
          type: string
          description: >-
            The definition this refers to. Any tag can propagate, including
            user-created ones.
        name:
          type: string
          description: >-
            Display name of the depended-on tag, resolved from the definition on
            this read. The "depends on" wording belongs to the client; this is
            the tag's own name.
        kind:
          $ref: '#/components/schemas/TagKind'
        color:
          type: string
          description: Display color, resolved from the definition.
        nearest_hops:
          type: integer
          description: >-
            Service boundaries crossed to the closest field carrying this tag
            directly. 0 means the source is on this same component. Sources are
            not enumerated; use the lineage explorer filtered to this field to
            see them.
      required:
        - tag_id
        - name
        - kind
        - nearest_hops
      additionalProperties: false
    TagKind:
      type: string
      description: >-
        Where a tag definition came from. SYSTEM tags are seeded by Gable
        (`pii`, `phi`, `pifi`, `secret`) and cannot be created or deleted
        through the API; the UI deactivates them instead. POST /v0/tags only
        ever mints USER tags.
      enum:
        - SYSTEM
        - USER
  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.