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

# Create a data store component.

> EXPERIMENTAL. Create a data store component in the component registry with its schema recorded as the first versioned snapshot. Returns the same detail resource as the component read.



## OpenAPI

````yaml /api-reference/bundled.yaml post /v0/experimental/components
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/components:
    post:
      tags:
        - lineage
      summary: Create a data store component.
      description: >-
        EXPERIMENTAL. Create a data store component in the component registry
        with its schema recorded as the first versioned snapshot. Returns the
        same detail resource as the component read.
      operationId: postExperimentalComponent
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ComponentCreateRequest'
      responses:
        '201':
          description: Component created.
          content:
            application/json:
              schema:
                type: object
                properties:
                  component:
                    $ref: '#/components/schemas/ComponentDetailResource'
                required:
                  - component
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Internal Server Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    ComponentCreateRequest:
      type: object
      description: >-
        EXPERIMENTAL. Register a data store component directly in the component
        registry, with its schema as the first versioned snapshot. The store
        becomes addressable as a discriminator edge endpoint immediately; no
        scan pipeline is involved.
      properties:
        type:
          type: string
          enum:
            - DATA_STORE
          description: Only DATA_STORE components can be created through this endpoint.
        name:
          type: string
          minLength: 1
          description: >-
            The store's canonical name (table, topic, index), used as its
            payload name on edges.
        friendly_name:
          type: string
          description: Optional display name.
        namespace:
          type: string
          description: The namespace the component belongs to.
        store_kind:
          type: string
          enum:
            - dynamodb
            - redis
            - elasticache
            - database
            - kafka
            - other
          description: Storage technology type.
        schema:
          type: object
          properties:
            fields:
              type: array
              minItems: 1
              items:
                type: object
                properties:
                  name:
                    type: string
                    minLength: 1
                  type:
                    type: string
                    minLength: 1
                required:
                  - name
                  - type
                additionalProperties: false
          required:
            - fields
          additionalProperties: false
        metadata:
          type: object
          description: Free-form registry metadata.
          additionalProperties:
            type: string
      required:
        - type
        - name
        - store_kind
        - schema
      additionalProperties: false
    ComponentDetailResource:
      type: object
      description: >
        Full component detail with paths in self-contained (round-trip) format.
        For CODE components, paths include inline ingress/egress boundary data.
        For DATA_STORE components, the schema field list is included.
      properties:
        id:
          type: string
          format: uuid
          description: Component UUID.
        name:
          type: string
          description: Human-readable component name.
        type:
          type: string
          enum:
            - CODE
            - DATA_STORE
          description: Component type ("CODE" or "DATA_STORE").
        namespace:
          type: string
          description: The namespace this component belongs to.
        friendly_name:
          type: string
          description: Optional friendly display name.
        paths:
          type: array
          description: Paths with inline boundary data (CODE components only).
          items:
            $ref: '#/components/schemas/LineagePath'
        approval:
          $ref: '#/components/schemas/ProjectionApproval'
          description: Projected approval state (CODE components only).
        store_kind:
          type: string
          enum:
            - dynamodb
            - redis
            - elasticache
            - database
            - kafka
            - other
          description: Storage technology type (DATA_STORE components only).
        schema:
          type: object
          description: Schema definition (DATA_STORE components only).
          properties:
            fields:
              type: array
              items:
                type: object
                properties:
                  name:
                    type: string
                  type:
                    type: string
                required:
                  - name
                  - type
        metadata:
          type: object
          description: Component metadata.
          additionalProperties: true
      required:
        - id
        - name
        - type
    ErrorResponse:
      type: object
      required:
        - message
      properties:
        id:
          type: number
        title:
          type: string
        message:
          type: string
    LineagePath:
      type: object
      description: >
        A path connecting an ingress to an egress within a component. Boundary
        data (schema, signature, kind) is inlined for round-trip editing. Fields
        marked readOnly are returned by GET but ignored on POST/PUT.
      properties:
        path_id:
          type: string
          format: uuid
          readOnly: true
          description: Server-assigned path ID.
        path_type:
          type: string
          enum:
            - SCAN_OUTPUT
            - USER_OVERRIDE
          readOnly: true
          description: Whether this path came from a scan or user override.
        is_suppressed:
          type: boolean
          readOnly: true
          description: Whether this path is currently suppressed.
          default: false
        ingress:
          $ref: '#/components/schemas/PathBoundary'
        egress:
          $ref: '#/components/schemas/PathBoundary'
        field_mappings:
          type: array
          items:
            $ref: '#/components/schemas/PathFieldMapping'
        code_anchors:
          type: array
          items:
            $ref: '#/components/schemas/PathCodeAnchor'
        transformation_summary:
          type: string
          description: Brief summary of the data transformation on this path.
        payload_name:
          type: string
          description: The payload name for this path.
        completeness:
          $ref: '#/components/schemas/Completeness'
        reason:
          type: string
          writeOnly: true
          description: Optional reason for creating or updating this path.
        effective_since_commit_sha:
          type: string
          writeOnly: true
          description: >
            Commit SHA this path is effective from. When omitted, defaults to
            the latest scanned commit for the component. The backend resolves
            the corresponding commit timestamp from the scan history.
      required:
        - ingress
        - egress
    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
    PathBoundary:
      type: object
      description: >
        One side (ingress or egress) of a path, with full boundary data inlined.
        Matches the write model structure for round-trip editing.
      properties:
        id:
          type: string
          format: uuid
          description: The boundary (ingress/egress) ID.
        kind:
          type: string
          description: The boundary kind (e.g. "postgres", "gateway_response").
        signature_name:
          type: string
          description: The signature name (e.g. package/class/method).
        schema:
          type: object
          description: Schema definition for this boundary.
          additionalProperties: true
        payload_name:
          type: string
          description: The payload name associated with this boundary.
        description:
          type: string
          description: Optional description of this boundary.
        boundary_coordinates:
          $ref: '#/components/schemas/BoundaryCoordinates'
          readOnly: true
          description: >-
            Durable coordinates of this boundary. Copy the object to address its
            fields in a write; the neighbouring `payload_name` and
            `signature_name` are display values and can differ. Absent from scan
            only reads.
        field_tags:
          type: array
          readOnly: true
          description: >-
            Tags on this boundary's fields, one entry per tagged field path.
            Computed per read. Absent from scan only reads.
          items:
            $ref: '#/components/schemas/FieldTagEntry'
        field_depends_on_tags:
          type: array
          readOnly: true
          description: >-
            Tags this boundary's fields depend on through lineage, one entry per
            field with at least one. Derived per read by walking the whole
            cross-service graph, so absent when that graph cannot be loaded.
          items:
            $ref: '#/components/schemas/FieldDependsOnTagEntry'
      required:
        - signature_name
    PathFieldMapping:
      type: object
      description: A field-level mapping on a path (ingress to egress).
      properties:
        ingress_field:
          type: string
          description: The field name on the ingress side.
        egress_field:
          type: string
          description: The field name on the egress side.
        notes:
          type: string
          description: Optional notes about this field mapping.
        kind:
          allOf:
            - $ref: '#/components/schemas/FieldMappingKind'
          description: The type of data flow this mapping represents.
      required:
        - ingress_field
        - egress_field
    PathCodeAnchor:
      type: object
      description: A code location anchor associated with a path.
      properties:
        anchor_id:
          type: string
          description: Unique identifier for this anchor.
        name:
          type: string
          description: Human-readable name for this anchor.
        file:
          type: string
          description: File path relative to project root.
        line_start:
          type: integer
          description: Starting line number.
        line_end:
          type: integer
          description: Ending line number.
        column_start:
          type: integer
          description: Starting column number.
        column_end:
          type: integer
          description: Ending column number.
        url:
          type: string
          description: Full URL to this code location (if available).
      required:
        - anchor_id
    Completeness:
      type: object
      properties:
        ingress:
          $ref: '#/components/schemas/CompletenessClassification'
          description: >-
            The completeness of non-schema ingress elements (name, signature,
            code anchor, etc.).
        ingress_schema:
          $ref: '#/components/schemas/CompletenessClassification'
          description: The completeness of the ingress's field schema.
        egress:
          $ref: '#/components/schemas/CompletenessClassification'
          description: >-
            The completeness of non-schema egress elements (name, signature,
            code anchor, etc.).
        egress_schema:
          $ref: '#/components/schemas/CompletenessClassification'
          description: The completeness of the egress's field schema.
        field_mappings:
          $ref: '#/components/schemas/CompletenessClassification'
          description: The completeness of the field mappings.
      required:
        - ingress
        - ingress_schema
        - egress
        - egress_schema
        - field_mappings
    BoundaryCoordinates:
      type: object
      description: >-
        Durable coordinates identifying one ingress or egress boundary. Either
        may be null.


        Copy this object rather than rebuilding it from the `payloadName` and
        `signatureName` beside it, which are filled in for display. A boundary
        the scan gave no payload name, on a path named `orders`, reads as
        `payloadName: "orders"` while its coordinates are `payload_name: null,
        signature_name: "OrdersController.create"`.
      properties:
        payload_name:
          description: The scanner's payload name, or null where it recorded none.
          anyOf:
            - type: string
            - type: 'null'
        signature_name:
          description: The package, class or method, or null where the scan recorded none.
          anyOf:
            - type: string
            - type: 'null'
      required:
        - payload_name
        - signature_name
      additionalProperties: false
      example:
        payload_name: null
        signature_name: OrdersController.create
    FieldTagEntry:
      type: object
      description: >-
        The effective tags on one field of the boundary carrying this entry.
        Shared by every read model that decorates a boundary, so the two sides
        cannot drift.
      properties:
        field_path:
          type: string
          description: >-
            Dotted flattened field path within this boundary's payload. The
            field half of the tag address; the boundary supplies the other half.
        tags:
          type: array
          description: Effective tags on that field, direct and inherited.
          items:
            $ref: '#/components/schemas/FieldTagRef'
      required:
        - field_path
        - tags
      additionalProperties: false
    FieldDependsOnTagEntry:
      type: object
      description: >-
        The tags one field of the carrying boundary depends on through lineage.
        Kept separate from `field_tags` so a derived tag can never be mistaken
        for one applied to the field, and so it is clear nothing here is
        removable.
      properties:
        field_path:
          type: string
          description: >-
            Dotted flattened field path within this boundary's payload,
            addressed the same way `field_tags` entries are.
        depends_on:
          type: array
          description: Tags reachable upstream of that field, one entry per distinct tag.
          items:
            $ref: '#/components/schemas/DependsOnTagRef'
      required:
        - field_path
        - depends_on
      additionalProperties: false
    FieldMappingKind:
      type: string
      description: >
        How a field mapping participates in the path.

        - DataFlow: the ingress field's value flows into the egress field
        (default).

        - KeyValueBridge: the mapping bridges a key/value pair rather than
        copying a single value.

        - ControlFlow: the ingress field influences whether/how the egress field
        is produced, but is not its value.

        When absent, treat as DataFlow.
      enum:
        - DataFlow
        - KeyValueBridge
        - ControlFlow
    CompletenessClassification:
      type: string
      description: A completeness classification of a ground truth element.
      enum:
        - UNKNOWN
        - KNOWN_INCOMPLETE
        - KNOWN_COMPLETE
    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.