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

# BatchChange

> BatchChange retrieves multiple entity changes by their IDs in a single request.
 This is an optimized endpoint for fetching specific changes when you already know their IDs,
 rather than listing changes for an entity.



## OpenAPI

````yaml /api-reference/openapi.yaml post /api/changes/v1/by-id
openapi: 3.1.0
info:
  version: '1.0'
  title: SYNQ
servers:
  - url: https://developer.synq.io
  - url: https://api.us.synq.io
security:
  - bearerAuth: []
tags:
  - name: synq.issues.issues.v1.IssuesService
    description: IssuesService is a service for managing Issues.
  - name: synq.issues.v2.IssuesService
    description: IssuesService is a service for managing Issues.
  - name: synq.incidents.v1.IncidentsService
    description: IncidentsService is a service for managing Incidents.
  - name: synq.alerts.services.v1.AlertsService
    description: AlertsService provides operations for managing alert configurations.
  - name: synq.agent.recon.v1.YamlService
    description: >-
      YamlService provides stateless conversion between YAML config format and
      proto.
       This is useful for UI editors that need to display/edit suite configs as YAML.
  - name: synq.agent.recon.v1.SuiteDeploymentService
    description: |-
      SuiteDeploymentService is the platform plane of reconciliation.

       SuiteConfigService is the developer/authoring sandbox (edit, version, run
       ad-hoc with your own credentials — preview-only, no Entity, no Run, no
       Issue). A deployment is what SYNQ actually runs on the workspace's behalf:
       a frozen snapshot of a suite config, mapped to workspace-level SYNQ
       integrations, optionally scheduled or triggerable by API.

       Identity: every deployment has a stable deployment_id (UUIDv7) assigned on
       first promote. It survives re-promotes, schedule/mapping changes, and
       pause/resume. Downstream AssetCommand / RunCommand publication keys off
       deployment_id so Entity identity does not fragment on promote churn.
  - name: synq.agent.sre.v1.TriageService
    description: >-
      Service for managing issue triage operations, allowing LLM agents to
      conclude investigations
       and record evidence during the triage process.
  - name: synq.agent.sre.v1.LlmService
    description: Service for evaluating LLM requests and producing structured output.
  - name: synq.agent.sre.v1.FeatureRequestService
    description: >-
      FeatureRequestService allows MCP clients to submit feature requests when
      users encounter
       missing capabilities. This is a last-resort service — it should only be used when no
       existing tool can fulfill the user's request.
  - name: synq.integrations.v1.IntegrationsService
    description: |-
      IntegrationsService manages connections from Coalesce Quality to your data
       systems (warehouses, databases, and transformation tools).

       Concurrency: every integration carries an opaque `etag`. Read it from
       `GetIntegration` / `ListIntegrations`, then pass it back on
       `UpdateIntegration` / `DeleteIntegration` to ensure you modify the version you
       last saw. A stale etag is rejected with ABORTED (HTTP 409). Omit
       the etag for last-write-wins.

       Quota: each workspace has a limit on the number of integrations. Creating
       beyond the limit is rejected with RESOURCE_EXHAUSTED.

       Secrets: credential fields (passwords, tokens, keys) are write-only. They are
       masked (returned empty) on every read. On update, omit a secret to keep it,
       send a new value to rotate it, or send an explicit empty string to clear it
       (where the field is `optional`).
  - name: synq.auth.iam.v1.IamService
  - name: synq.monitors.predictions.v1.MonitorPredictionsService
    description: Access to anomaly detection model predictions and raw metric timeseries.
  - name: synq.monitors.info.v1.MonitorInfoService
  - name: synq.monitors.custom_monitors.v1.CustomMonitorsService
  - name: synq.monitors.history.v1.HistoryService
  - name: synq.monitors.automated_monitors.v1.DeploymentRulesService
  - name: synq.entities.executions.v2.EntityExecutionsService
    description: >-
      EntityExecutionsService provides read-only access to entity execution
      history.
       This service allows customers to retrieve information about all executions that happened on their entities,
       including execution status, timing, and messages.

       Use cases:
       - Retrieve execution history for specific entities
       - Filter executions by time range, status, or execution type
       - Get aggregated summaries of execution activity
       - Track execution trends and patterns
  - name: synq.datachecks.sqltests.v1.SqlTestsService
    description: SqlTestsService is a service for managing SqlTests.
  - name: synq.datachecks.v1.TriggerService
    description: TriggerService provides synchronous execution of datachecks on entities.
  - name: synq.datachecks.testsuggestions.v1.TestSuggestionsService
  - name: synq.extensions.atlan.provider.v1.AtlanProviderService
  - name: synq.extensions.atlan.integrations.v1.AtlanIntegrationService
  - name: synq.extensions.atlan.workflows.v1.AtlanWorkflowService
  - name: synq.savedviews.v1.SavedViewsService
    description: >-
      SavedViewsService manages saved views — named, reusable selections over
      your
       entities (and other surfaces) with display configuration, sharing and
       per-user pinning.

       A saved view is owned by the user who created it. It can be kept private,
       shared with the whole workspace, or granted to specific users. Reads return,
       for the calling user, how each view relates to them (mine / shared / granted)
       and what they are allowed to do with it. Workspace administrators can manage
       any view in the workspace.
  - name: synq.platforms.v1.PlatformsService
    description: PlatformsService is a service for managing Platforms and Integrations.
  - name: synq.queries.v1.NLQueryService
    description: >-
      NLQueryService generates structured Query protos from natural language
      descriptions using an LLM.
  - name: synq.schedule.v1.ScheduleService
    description: ScheduleService provides schedule evaluation utilities.
  - name: synq.entities.executions.v1.EntityExecutionsService
    description: 'Deprecated: Use [synq.entities.custom.v1.EntityExecutionsService] instead'
  - name: synq.entities.status.v1.EntityIncidentsService
    description: EntityIncidentsService is the service which retrieves entity status.
  - name: synq.entities.status.v1.EntityIssuesService
    description: EntityIssuesService is the service which retrieves entity issues status.
  - name: synq.entities.orchestration.v1.OrchestrationService
    description: >-
      OrchestrationService provides information about orchestration
      relationships between entities.
       This includes relationships between Airflow tasks and transformation models (dbt, SQLMesh),
       as well as task-to-task dependencies.
  - name: synq.entities.coordinates.v1.DatabaseCoordinatesService
    description: >-
      DatabaseCoordinatesService is a service for getting database coordinates
      of Entities.
  - name: synq.entities.checks.v1.ChecksCategoriesService
    description: |-
      ChecksCategoriesService lets workspace admins set explicit category
       overrides on individual checks. An explicit category is the
       authoritative category for a check — it takes precedence over the
       categories computed by the workspace's categorisation rules.

       It is a public API so customers can manage check categories
       programmatically; the same service is also mounted on the internal
       API. The workspace and the acting identity are always taken from the
       request context, never from the payload.
  - name: synq.entities.sql_insights.v1.SqlInsightsService
    description: >-
      SqlInsightsService exposes analytical information about the SQL used
      across a
       workspace's entities. It answers questions such as "which SQL constructs are
       used in my warehouse, and how often" and "what SQL constructs does this
       specific entity use", without requiring the caller to re-parse any SQL.
  - name: synq.entities.custom.v1.RelationshipsService
    description: >-
      RelationshipsService allow management of relationships between entities.
      Relationships can
       be created, updated, and deleted between 2 custom entities, or between a custom entity and Coalesce Quality native entity.enum
       There is no option to create relationships between 2 Coalesce Quality native entities (dbt model, BI dashboard, etc.).
  - name: synq.entities.custom.v1.TypesService
    description: TypesService is a service for managing custom entity types.
  - name: synq.entities.custom.v1.GroupsService
    description: >-
      It eliminates the need to keep state on client side to remember which
      assets were already created
       and which should be deleted. The server will keep track of the current state of the group and client
       can always send the intended new state. The server will calculate the diff and entities that are
       no longer present in the group will be removed.

       Example:
       1. group has entities A, B, C at time t1
       2. client sends group with entities B, C, D at time t2
       3. server will remove entity A from the system and update the current state of the group to B, C, D

       The service is designed to be idempotent and can be called multiple times with the same state without
       causing any side effects.
  - name: synq.entities.custom.v1.EntityExecutionsService
  - name: synq.entities.custom.v1.EntitiesService
    description: >-
      custom.EntitiesService is a service for managing custom entities. Entities
      can represent
       various data platform concepts such as services, consumers, applications or data pipelines
       that are not natively available in Coalesce Quality.

       Entities are identified by a unique identifier and can be created, updated, read and deleted.
  - name: synq.entities.custom.v1.FeaturesService
  - name: synq.entities.impact.v1.ImpactService
  - name: synq.entities.schemas.v1.SchemaMismatchesService
    description: >-
      SchemaMismatchesService provides access to schema drift information
      between
       data platform tables and their definitions (e.g., dbt models).
  - name: synq.entities.schemas.v1.SchemasService
    description: EntitiesService is a service for retriving any entity.
  - name: synq.entities.constraints.v1.TableConstraintsService
    description: >-
      TableConstraintsService provides access to table constraint and index
      information.
  - name: synq.entities.changes.v1.ChangesService
    description: >-
      ChangesService provides functionality to track and retrieve all types of
      changes to data entities.

       This unified service returns ALL change types for an entity:
       - Git commits: Changes to code files (dbt models, SQL files) tracked in version control
       - Schema changes: Database schema modifications (columns added/removed/changed)
       - SQL definition changes: View/materialized view definition updates detected by Coalesce Quality

       Changes are returned with structured metadata including:
       - For git commits: structured statistics (directories, file types, top changes)
       - For schema changes: detailed column-level diffs
       - For SQL changes: before/after SQL definitions

       Use cases:
       - "What changed in the last week for table X?" → Returns git commits, schema changes, SQL changes
       - "Show me all commits affecting this dbt model" → Returns git commits with lineage context
       - "What schema changes happened to this table?" → Returns schema changes detected by Coalesce Quality
  - name: synq.entities.lineage.v1.LineageService
    description: |-
      LineageService allows you to fetch:
       * Entity level lineage from a starting point of one or more entities.
       * Column Level lineage from a starting point of multiple columns of a single entity.
  - name: synq.entities.entities.v1.EntitiesService
    description: EntitiesService is a service for retriving any entity.
  - name: synq.entities.annotations.v1.AnnotationsService
    description: >-
      AnnotationsService provides operations for managing and querying entity
      annotations.
       Annotations are key-value pairs that can be attached to entities for categorization and filtering.
  - name: synq.entities.code.v1.CodeService
    description: >-
      CodeService is a service for retrieving code associated with entities in
      the system.
       It provides functionality to access and manage code artifacts such as SQL queries,
       Python scripts, dbt models, and other code configurations that are part of Coalesce Quality entities.
  - name: synq.entities.resolve.v1.IdentifierResolveService
    description: >-
      IdentifierResolveService resolves identifiers to their Coalesce Quality
      paths and identities.
  - name: synq.ingest.airflow.v1.AirflowLogsService
  - name: synq.ingest.cloudwatch.v1.CloudwatchService
  - name: synq.ingest.openlineage.v1.OpenlineageService
  - name: synq.ingest.dwh.v1.DwhService
  - name: synq.dataproducts.v1.DataproductsService
    description: DataproductsService can be used to manage data products.
  - name: synq.git.commits.v1.CommitsService
paths:
  /api/changes/v1/by-id:
    post:
      tags:
        - synq.entities.changes.v1.ChangesService
      summary: BatchChange
      description: >-
        BatchChange retrieves multiple entity changes by their IDs in a single
        request.
         This is an optimized endpoint for fetching specific changes when you already know their IDs,
         rather than listing changes for an entity.
      operationId: synq.entities.changes.v1.ChangesService.BatchChange
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/synq.entities.changes.v1.BatchChangeRequest'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/synq.entities.changes.v1.BatchChangeResponse
components:
  schemas:
    synq.entities.changes.v1.BatchChangeRequest:
      type: object
      properties:
        changeIds:
          type: array
          items:
            type: string
          description: >-
            List of change IDs to retrieve. Each ID uniquely identifies a
            specific change in the system.
      title: BatchChangeRequest
      additionalProperties: false
      description: >-
        BatchChangeRequest contains the parameters needed to retrieve multiple
        changes by their IDs.
    synq.entities.changes.v1.BatchChangeResponse:
      type: object
      properties:
        changes:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/synq.entities.v1.EntityChange'
            title: value
          description: >-
            Map of change ID to EntityChange. Only includes changes that were
            found and accessible.
             Missing changes are omitted from the response.
      title: BatchChangeResponse
      additionalProperties: false
      description: BatchChangeResponse contains the requested changes mapped by their IDs.
    synq.entities.v1.EntityChange:
      type: object
      allOf:
        - properties:
            entityId:
              $ref: '#/components/schemas/synq.entities.v1.Identifier'
              title: entity_id
              description: >-
                Identifier of the entity on which the change was detected when
                available.
            entitySynqPath:
              type: string
              title: entity_synq_path
              description: >-
                Coalesce Quality path representing entity on which the change
                was detected when available,
              nullable: true
            affectedEntities:
              type: array
              items:
                $ref: '#/components/schemas/synq.entities.v1.Identifier'
              title: affected_entities
              description: Identifiers of entities directly affected by this change.
            affectedEntitiesSynqPaths:
              type: array
              items:
                type: string
              title: affected_entities_synq_paths
              description: >-
                Coalesce Quality paths of entities directly affected by this
                change.
            changeId:
              type: string
              title: change_id
              description: Internal identifier of the change event.
            changeDetectedAt:
              $ref: '#/components/schemas/google.protobuf.Timestamp'
              title: change_detected_at
              description: Timestamp when the change was detected by Coalesce Quality.
        - oneOf:
            - properties:
                gitCommit:
                  $ref: '#/components/schemas/synq.entities.v1.GitCommitChange'
                  title: git_commit
              title: git_commit
              required:
                - gitCommit
            - properties:
                schema:
                  $ref: '#/components/schemas/synq.entities.v1.SchemaChange'
                  title: schema
              title: schema
              required:
                - schema
            - properties:
                sqlDefinition:
                  $ref: '#/components/schemas/synq.entities.v1.SqlDefinitionChange'
                  title: sql_definition
              title: sql_definition
              required:
                - sqlDefinition
      title: EntityChange
      required:
        - entityId
        - changeId
        - changeDetectedAt
      additionalProperties: false
      description: >-
        EntityChange represents a change detected in an entity within the
        system.
         It tracks modifications to entities like Git commits, SQL definitions, and database schemas.
    synq.entities.v1.Identifier:
      type: object
      oneOf:
        - properties:
            airflowDag:
              $ref: '#/components/schemas/synq.entities.v1.AirflowDagIdentifier'
              title: airflow_dag
              description: Airflow DAG identifier
          title: airflow_dag
          required:
            - airflowDag
        - properties:
            airflowTask:
              $ref: '#/components/schemas/synq.entities.v1.AirflowTaskIdentifier'
              title: airflow_task
              description: Airflow task identifier within a given DAG
          title: airflow_task
          required:
            - airflowTask
        - properties:
            athenaTable:
              $ref: '#/components/schemas/synq.entities.v1.AthenaTableIdentifier'
              title: athena_table
              description: Amazon Athena (Glue) table identifier
          title: athena_table
          required:
            - athenaTable
        - properties:
            bigqueryTable:
              $ref: '#/components/schemas/synq.entities.v1.BigqueryTableIdentifier'
              title: bigquery_table
              description: BigQuery table identifier
          title: bigquery_table
          required:
            - bigqueryTable
        - properties:
            clickhouseTable:
              $ref: '#/components/schemas/synq.entities.v1.ClickhouseTableIdentifier'
              title: clickhouse_table
              description: Clickhouse table identifier
          title: clickhouse_table
          required:
            - clickhouseTable
        - properties:
            custom:
              $ref: '#/components/schemas/synq.entities.v1.CustomIdentifier'
              title: custom
              description: Custom identifier to be used with all custom created entities
          title: custom
          required:
            - custom
        - properties:
            databricksTable:
              $ref: '#/components/schemas/synq.entities.v1.DatabricksTableIdentifier'
              title: databricks_table
              description: Databricks table identifier
          title: databricks_table
          required:
            - databricksTable
        - properties:
            dataproduct:
              $ref: '#/components/schemas/synq.entities.v1.DataproductIdentifier'
              title: dataproduct
              description: Dataproduct identifier
          title: dataproduct
          required:
            - dataproduct
        - properties:
            dbtCloudNode:
              $ref: '#/components/schemas/synq.entities.v1.DbtCloudNodeIdentifier'
              title: dbt_cloud_node
              description: >-
                Dbt node that identifies one of dbt DAG nodes (model, test, etc)
                in dbt Cloud project
          title: dbt_cloud_node
          required:
            - dbtCloudNode
        - properties:
            dbtCoreNode:
              $ref: '#/components/schemas/synq.entities.v1.DbtCoreNodeIdentifier'
              title: dbt_core_node
              description: >-
                Dbt node that identifies one of dbt DAG nodes (model, test, etc)
                in dbt Core project
          title: dbt_core_node
          required:
            - dbtCoreNode
        - properties:
            monitor:
              $ref: '#/components/schemas/synq.entities.v1.MonitorIdentifier'
              title: monitor
              description: Monitor identifier
          title: monitor
          required:
            - monitor
        - properties:
            mssqlTable:
              $ref: '#/components/schemas/synq.entities.v1.MssqlTableIdentifier'
              title: mssql_table
              description: SQL Server table identifier
          title: mssql_table
          required:
            - mssqlTable
        - properties:
            mysqlTable:
              $ref: '#/components/schemas/synq.entities.v1.MysqlTableIdentifier'
              title: mysql_table
              description: Mysql table identifier
          title: mysql_table
          required:
            - mysqlTable
        - properties:
            oracleTable:
              $ref: '#/components/schemas/synq.entities.v1.OracleTableIdentifier'
              title: oracle_table
              description: Oracle table identifier
          title: oracle_table
          required:
            - oracleTable
        - properties:
            postgresTable:
              $ref: '#/components/schemas/synq.entities.v1.PostgresTableIdentifier'
              title: postgres_table
              description: Postgres table identifier
          title: postgres_table
          required:
            - postgresTable
        - properties:
            redshiftTable:
              $ref: '#/components/schemas/synq.entities.v1.RedshiftTableIdentifier'
              title: redshift_table
              description: Redshift table identifier
          title: redshift_table
          required:
            - redshiftTable
        - properties:
            savedView:
              $ref: '#/components/schemas/synq.entities.v1.SavedViewIdentifier'
              title: saved_view
              description: Saved view identifier
          title: saved_view
          required:
            - savedView
        - properties:
            snowflakeTable:
              $ref: '#/components/schemas/synq.entities.v1.SnowflakeTableIdentifier'
              title: snowflake_table
              description: Snowflake table identifier
          title: snowflake_table
          required:
            - snowflakeTable
        - properties:
            sqlMeshAudit:
              $ref: '#/components/schemas/synq.entities.v1.SqlMeshAuditIdentifier'
              title: sql_mesh_audit
              description: SQLMesh Audit identifier
          title: sql_mesh_audit
          required:
            - sqlMeshAudit
        - properties:
            sqlMeshModel:
              $ref: '#/components/schemas/synq.entities.v1.SqlMeshModelIdentifier'
              title: sql_mesh_model
              description: SQLMesh Model identifier
          title: sql_mesh_model
          required:
            - sqlMeshModel
        - properties:
            synqPath:
              $ref: '#/components/schemas/synq.entities.v1.SynqPathIdentifier'
              title: synq_path
              description: SynqPath identifier
          title: synq_path
          required:
            - synqPath
        - properties:
            trinoTable:
              $ref: '#/components/schemas/synq.entities.v1.TrinoTableIdentifier'
              title: trino_table
              description: Trino table identifier
          title: trino_table
          required:
            - trinoTable
      additionalProperties: false
      description: >-
        Identifier is a unique reference to an entity in Coalesce Quality
        system. Entity identifiers
         are designed to closely mimic identifiers used by data platforms and tools. To construct
         an identifier, you need to know the kind of the entity and the ids that you would normally
         use to identify it in the data platform or tool. For example, to identify a table in BigQuery,
         you would need to know the project, dataset, and table names.
    google.protobuf.Timestamp:
      type: string
      examples:
        - '2023-01-15T01:30:15.01Z'
        - '2024-12-25T12:00:00Z'
      format: date-time
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

         All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
         second table is needed for interpretation, using a [24-hour linear
         smear](https://developers.google.com/time/smear).

         The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
         restricting to that range, we ensure that we can convert to and from [RFC
         3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

         # Examples

         Example 1: Compute Timestamp from POSIX `time()`.

             Timestamp timestamp;
             timestamp.set_seconds(time(NULL));
             timestamp.set_nanos(0);

         Example 2: Compute Timestamp from POSIX `gettimeofday()`.

             struct timeval tv;
             gettimeofday(&tv, NULL);

             Timestamp timestamp;
             timestamp.set_seconds(tv.tv_sec);
             timestamp.set_nanos(tv.tv_usec * 1000);

         Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

             FILETIME ft;
             GetSystemTimeAsFileTime(&ft);
             UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

             // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
             // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
             Timestamp timestamp;
             timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
             timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

         Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

             long millis = System.currentTimeMillis();

             Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
                 .setNanos((int) ((millis % 1000) * 1000000)).build();


         Example 5: Compute Timestamp from Java `Instant.now()`.

             Instant now = Instant.now();

             Timestamp timestamp =
                 Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                     .setNanos(now.getNano()).build();


         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

         In JSON format, the Timestamp type is encoded as a string in the
         [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
         format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
         where {year} is always expressed using four digits while {month}, {day},
         {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
         seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
         are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
         is required. A proto3 JSON serializer should always use UTC (as indicated by
         "Z") when printing the Timestamp type and a proto3 JSON parser should be
         able to accept both UTC and other timezones (as indicated by an offset).

         For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
         01:30 UTC on January 15, 2017.

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
         ) to obtain a formatter capable of generating timestamps in this format.
    synq.entities.v1.GitCommitChange:
      type: object
      properties:
        hash:
          type: string
          description: Hash of the Git commit.
        author:
          $ref: '#/components/schemas/synq.entities.v1.GitCommitChange.Signature'
          description: Author information of the Git commit.
        committer:
          $ref: '#/components/schemas/synq.entities.v1.GitCommitChange.Signature'
          description: Committer information of the Git commit.
        message:
          type: string
          description: Commit message describing the changes.
        shortMessage:
          type: string
          description: First non-empty line of the message
        fileChangeStats:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/synq.entities.v1.GitCommitChange.ChangeStats'
            title: value
          description: Statistics about changes made to each modified file.
        changedFilePaths:
          type: array
          items:
            type: string
          description: |-
            All file paths changed in this commit (complete list).
             For commits with many files, this may be a large array.
        relatedChangedFilePaths:
          type: array
          items:
            type: string
          description: >-
            File paths that directly affect the queried entity (filtered subset
            of changed_file_paths).
             When querying changes for a specific entity (e.g., dbt model "customers"), this contains
             only the files that directly impact that entity (e.g., "models/customers.sql", "models/staging/stg_customers.sql").
             Empty when retrieving a change by change_id directly (not scoped to a specific entity).
             Empty when it's impossible to determine entity-specific file mappings.
             Example: If a commit changes 50 files but only 2 affect your queried dbt model, this contains those 2 files.
        branchName:
          type: string
          description: Name of the branch associated with the commit, if any.
          nullable: true
        cloneUrl:
          type: string
          description: URL of the Git repository where the commit was made.
        webCommitUrl:
          type: string
          description: URL to e.g. Github which opens the Commit
          nullable: true
        directoryChanges:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.entities.v1.GitCommitChange.DirectoryChangeSummary
          description: Hierarchical directory summaries showing where changes occurred.
        changesByFileType:
          type: object
          additionalProperties:
            $ref: >-
              #/components/schemas/synq.entities.v1.GitCommitChange.FileTypeChangeSummary
            title: value
          description: Aggregated statistics by file type/extension.
        statistics:
          $ref: >-
            #/components/schemas/synq.entities.v1.GitCommitChange.ChangeStatistics
          description: Overall statistical summary of the commit.
          nullable: true
      title: GitCommitChange
      additionalProperties: false
      description: GitCommitChange represents a change detected in a Git repository.
    synq.entities.v1.SchemaChange:
      type: object
      properties:
        columnChanges:
          type: array
          items:
            $ref: '#/components/schemas/synq.entities.v1.SchemaColumnChange'
          description: List of changes made to individual columns in the schema.
      title: SchemaChange
      additionalProperties: false
      description: SchemaChange represents a change detected in a database schema.
    synq.entities.v1.SqlDefinitionChange:
      type: object
      properties:
        previousSql:
          type: string
          description: Previous version of the SQL definition.
        previousSqlStateAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          description: Timestamp when the previous SQL state was valid.
        currentSql:
          type: string
          description: Current version of the SQL definition.
        currentSqlStateAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          description: Timestamp when the current SQL state became valid.
        sqlDiff:
          type: string
          description: Diff showing the changes between previous and current SQL.
      title: SqlDefinitionChange
      additionalProperties: false
      description: SqlDefinitionChange represents a change detected in a SQL definition.
    synq.entities.v1.AirflowDagIdentifier:
      type: object
      properties:
        integrationId:
          type: string
          description: Coalesce Quality integration_id that identifies the Airflow instance
        dagId:
          type: string
          description: Airflow dag_id that identifies the DAG
      title: AirflowDagIdentifier
      required:
        - integrationId
        - dagId
      additionalProperties: false
    synq.entities.v1.AirflowTaskIdentifier:
      type: object
      properties:
        integrationId:
          type: string
          description: Coalesce Quality integration_id that identifies the Airflow instance
        dagId:
          type: string
          description: Airflow dag_id that identifies the DAG
        taskId:
          type: string
          description: Airflow task_id that identifies the task within the DAG
      title: AirflowTaskIdentifier
      required:
        - integrationId
        - dagId
        - taskId
      additionalProperties: false
    synq.entities.v1.AthenaTableIdentifier:
      type: object
      properties:
        instance:
          type: string
          description: |-
            AWS account and region the Athena workgroup runs in, formatted as
             "<account-id>.<region>" (e.g. "123456789012.eu-west-1"). Auto-derived
             from sts:GetCallerIdentity at integration setup time.
        catalog:
          type: string
          description: |-
            Glue Data Catalog name. Almost always "AwsDataCatalog" — the default
             catalog for Athena unless the customer registered a federated catalog.
        database:
          type: string
          description: Glue database (the namespace users typically filter on).
        table:
          type: string
          description: Glue table or view name.
      title: AthenaTableIdentifier
      required:
        - instance
        - catalog
        - database
        - table
      additionalProperties: false
    synq.entities.v1.BigqueryTableIdentifier:
      type: object
      properties:
        project:
          type: string
          description: BigQuery project
        dataset:
          type: string
          description: BigQuery dataset id
        table:
          type: string
          description: BigQuery table name
      title: BigqueryTableIdentifier
      required:
        - project
        - dataset
        - table
      additionalProperties: false
    synq.entities.v1.ClickhouseTableIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Clickhouse hostname without port
        schema:
          type: string
          description: Clickhouse database
        table:
          type: string
          description: Clickhouse table
      title: ClickhouseTableIdentifier
      required:
        - host
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.CustomIdentifier:
      type: object
      properties:
        id:
          type: string
          description: |-
            Id that identifies the custom entity
             The Id should be unique within the custom entity Identifier.
      title: CustomIdentifier
      required:
        - id
      additionalProperties: false
    synq.entities.v1.DatabricksTableIdentifier:
      type: object
      properties:
        workspace:
          type: string
          description: URL of Databricks workspace
        catalog:
          type: string
          description: Databricks catalog
        schema:
          type: string
          description: Databricks schema
        table:
          type: string
          description: Databricks table or view
      title: DatabricksTableIdentifier
      required:
        - workspace
        - catalog
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.DataproductIdentifier:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: Dataproduct id that identifies the Dataproduct
      title: DataproductIdentifier
      required:
        - id
      additionalProperties: false
    synq.entities.v1.DbtCloudNodeIdentifier:
      type: object
      properties:
        projectId:
          type: string
          description: Your dbt Cloud project id
        accountId:
          type: string
          description: Your dbt Cloud account id
        nodeId:
          type: string
          description: Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)
      title: DbtCloudNodeIdentifier
      required:
        - projectId
        - nodeId
      additionalProperties: false
    synq.entities.v1.DbtCoreNodeIdentifier:
      type: object
      properties:
        integrationId:
          type: string
          description: >-
            Opaque identifier of the dbt Core project. Usually the Coalesce
            Quality
             integration id (a UUID), but may also be the dbt project name from
             manifest.json when the integration is configured to identify assets by
             project name. Treat it as an opaque string, not a UUID.
        nodeId:
          type: string
          description: Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)
      title: DbtCoreNodeIdentifier
      required:
        - integrationId
        - nodeId
      additionalProperties: false
    synq.entities.v1.MonitorIdentifier:
      type: object
      properties:
        monitoredId:
          $ref: '#/components/schemas/synq.entities.v1.Identifier'
          description: Identifier of the monitored entity
        monitorId:
          type: string
          description: Identifier of the monitor
        segment:
          type: string
          description: Optional monitor segmentation identifier
          nullable: true
        integrationId:
          type: string
          description: Coalesce Quality integration_id of the monitored identifier
          nullable: true
          deprecated: true
      title: MonitorIdentifier
      required:
        - monitoredId
        - monitorId
      additionalProperties: false
    synq.entities.v1.MssqlTableIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Hostname of the SQL Server instance
        database:
          type: string
          description: SQL Server database
        schema:
          type: string
          description: SQL Server schema (e.g. "dbo")
        table:
          type: string
          description: SQL Server table or view
      title: MssqlTableIdentifier
      required:
        - host
        - database
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.MysqlTableIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Mysql hostname without port
        schema:
          type: string
          description: Mysql database
        table:
          type: string
          description: Mysql table
      title: MysqlTableIdentifier
      required:
        - host
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.OracleTableIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Hostname of the Oracle instance
        serviceName:
          type: string
          description: Oracle service name (PDB)
        schema:
          type: string
          description: Oracle schema (= owning user)
        table:
          type: string
          description: Oracle table or view
      title: OracleTableIdentifier
      required:
        - host
        - serviceName
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.PostgresTableIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Postgres hostname without port
        database:
          type: string
          description: Postgres database
        schema:
          type: string
          description: Postgres schema
        table:
          type: string
          description: Postgres table
      title: PostgresTableIdentifier
      required:
        - host
        - database
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.RedshiftTableIdentifier:
      type: object
      properties:
        cluster:
          type: string
          description: Redshift cluster
        database:
          type: string
          description: Redshift database
        schema:
          type: string
          description: Redshift schema
        table:
          type: string
          description: Redshift table
      title: RedshiftTableIdentifier
      required:
        - database
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.SavedViewIdentifier:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: Saved view id (client-supplied UUID) that identifies the saved view
      title: SavedViewIdentifier
      required:
        - id
      additionalProperties: false
    synq.entities.v1.SnowflakeTableIdentifier:
      type: object
      properties:
        account:
          type: string
          description: Snowflake account
        database:
          type: string
          description: Snowflake database
        schema:
          type: string
          description: Snowflake schema
        table:
          type: string
          description: Snowflake table
      title: SnowflakeTableIdentifier
      required:
        - account
        - database
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.SqlMeshAuditIdentifier:
      type: object
      properties:
        integrationId:
          type: string
          format: uuid
          description: Coalesce Quality integration_id that identifies the dbt Core project
        fqn:
          type: string
          description: SQLMesh model fully qualified name
        auditId:
          type: string
          description: Identifier of the audit
      title: SqlMeshAuditIdentifier
      required:
        - integrationId
        - fqn
        - auditId
      additionalProperties: false
    synq.entities.v1.SqlMeshModelIdentifier:
      type: object
      properties:
        integrationId:
          type: string
          format: uuid
          description: Coalesce Quality integration_id that identifies the dbt Core project
        fqn:
          type: string
          description: SQLMesh model fully qualified name
      title: SqlMeshModelIdentifier
      required:
        - integrationId
        - fqn
      additionalProperties: false
    synq.entities.v1.SynqPathIdentifier:
      type: object
      properties:
        path:
          type: string
          description: >-
            Coalesce Quality path that identifies the Coalesce Quality entity,
            needs to be one of supported paths
      title: SynqPathIdentifier
      required:
        - path
      additionalProperties: false
    synq.entities.v1.TrinoTableIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Hostname of the Trino instance
        catalog:
          type: string
          description: Trino catalog
        schema:
          type: string
          description: Trino schema
        table:
          type: string
          description: Trino table or view
      title: TrinoTableIdentifier
      required:
        - host
        - catalog
        - schema
        - table
      additionalProperties: false
    synq.entities.v1.GitCommitChange.Signature:
      type: object
      properties:
        name:
          type: string
          description: Name of the Git user.
        email:
          type: string
          description: Email address of the Git user.
        createdAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          description: Timestamp when the signature was created.
      title: Signature
      additionalProperties: false
      description: Signature contains information about the Git user who made the changes.
    synq.entities.v1.GitCommitChange.ChangeStats:
      type: object
      properties:
        additions:
          type: integer
          format: int32
          description: Number of lines added to the file.
        deletions:
          type: integer
          format: int32
          description: Number of lines removed from the file.
      title: ChangeStats
      additionalProperties: false
      description: ChangeStats contains statistics about changes made to a single file.
    synq.entities.v1.GitCommitChange.DirectoryChangeSummary:
      type: object
      properties:
        directoryPath:
          type: string
          description: Path of the directory.
        filesChanged:
          type: integer
          format: int32
          description: >-
            Number of files changed in this directory (excluding
            subdirectories).
        totalLinesAdded:
          type: integer
          format: int32
          description: Total lines added in this directory (excluding subdirectories).
        totalLinesRemoved:
          type: integer
          format: int32
          description: Total lines removed in this directory (excluding subdirectories).
        subdirs:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.entities.v1.GitCommitChange.DirectoryChangeSummary
          description: Subdirectory summaries.
        topFiles:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.entities.v1.GitCommitChange.TopFileChange
          description: Top 3-5 most significant file changes in this directory.
      title: DirectoryChangeSummary
      additionalProperties: false
      description: DirectoryChangeSummary provides hierarchical directory-level statistics.
    synq.entities.v1.GitCommitChange.FileTypeChangeSummary:
      type: object
      properties:
        fileExtension:
          type: string
          description: File extension (e.g., ".sql", ".py", ".yml").
        filesCount:
          type: integer
          format: int32
          description: Number of files with this extension that were changed.
        totalLinesAdded:
          type: integer
          format: int32
          description: Total lines added across all files of this type.
        totalLinesRemoved:
          type: integer
          format: int32
          description: Total lines removed across all files of this type.
        exampleFiles:
          type: array
          items:
            type: string
          description: Example file paths (up to 5) showing where these changes occurred.
        commonDirectories:
          type: array
          items:
            type: string
          description: Common directories where files of this type were modified.
      title: FileTypeChangeSummary
      additionalProperties: false
      description: FileTypeChangeSummary aggregates changes by file type/extension.
    synq.entities.v1.GitCommitChange.ChangeStatistics:
      type: object
      properties:
        totalFiles:
          type: integer
          format: int32
          description: Total number of files changed.
        totalLinesAdded:
          type: integer
          format: int32
          description: Total lines added across all files.
        totalLinesRemoved:
          type: integer
          format: int32
          description: Total lines removed across all files.
        distribution:
          $ref: >-
            #/components/schemas/synq.entities.v1.GitCommitChange.FileChangeDistribution
          description: Distribution of changes by magnitude.
        topChanges:
          type: array
          items:
            $ref: '#/components/schemas/synq.entities.v1.GitCommitChange.TopChange'
          description: Top 10 files by total lines changed.
      title: ChangeStatistics
      additionalProperties: false
      description: ChangeStatistics provides statistical summaries of the entire commit.
    synq.entities.v1.SchemaColumnChange:
      type: object
      oneOf:
        - properties:
            columnAddition:
              $ref: >-
                #/components/schemas/synq.entities.v1.SchemaColumnChange.ColumnAdditionChangeType
              title: column_addition
          title: column_addition
          required:
            - columnAddition
        - properties:
            columnNativeType:
              $ref: >-
                #/components/schemas/synq.entities.v1.SchemaColumnChange.ColumnNativeTypeChangeType
              title: column_native_type
          title: column_native_type
          required:
            - columnNativeType
        - properties:
            columnRemoval:
              $ref: >-
                #/components/schemas/synq.entities.v1.SchemaColumnChange.ColumnRemovalChangeType
              title: column_removal
          title: column_removal
          required:
            - columnRemoval
      additionalProperties: false
      description: >-
        SchemaColumnChange represents a specific change to a column in the
        schema.
    synq.entities.v1.GitCommitChange.TopFileChange:
      type: object
      properties:
        filePath:
          type: string
          description: Path of the file relative to the directory.
        linesAdded:
          type: integer
          format: int32
          description: Number of lines added.
        linesRemoved:
          type: integer
          format: int32
          description: Number of lines removed.
      title: TopFileChange
      additionalProperties: false
      description: TopFileChange represents a significant file change within a directory.
    synq.entities.v1.GitCommitChange.FileChangeDistribution:
      type: object
      properties:
        filesWithSmallChanges:
          type: integer
          format: int32
          description: Files with fewer than 10 lines changed.
        filesWithMediumChanges:
          type: integer
          format: int32
          description: Files with 10-100 lines changed.
        filesWithLargeChanges:
          type: integer
          format: int32
          description: Files with more than 100 lines changed.
        filesAdded:
          type: integer
          format: int32
          description: Files that were newly added.
        filesModified:
          type: integer
          format: int32
          description: Files that were modified.
        filesDeleted:
          type: integer
          format: int32
          description: Files that were deleted.
      title: FileChangeDistribution
      additionalProperties: false
      description: FileChangeDistribution categorizes files by change magnitude.
    synq.entities.v1.GitCommitChange.TopChange:
      type: object
      properties:
        filePath:
          type: string
          description: Path of the file.
        linesAdded:
          type: integer
          format: int32
          description: Lines added.
        linesRemoved:
          type: integer
          format: int32
          description: Lines removed.
        totalLinesChanged:
          type: integer
          format: int32
          description: Total lines changed (added + removed).
      title: TopChange
      additionalProperties: false
      description: TopChange represents one of the most significant file changes.
    synq.entities.v1.SchemaColumnChange.ColumnAdditionChangeType:
      type: object
      properties:
        columnId:
          type: string
          description: Identifier of the new column.
        nativeType:
          type: string
          description: Data type of the new column.
        ordinalPosition:
          type: integer
          format: int32
          description: Position where the column was added in the schema.
      title: ColumnAdditionChangeType
      additionalProperties: false
      description: >-
        ColumnAdditionChangeType represents the addition of a new column to the
        schema.
    synq.entities.v1.SchemaColumnChange.ColumnNativeTypeChangeType:
      type: object
      properties:
        columnId:
          type: string
          description: Identifier of the modified column.
        previousNativeType:
          type: string
          description: Previous data type of the column.
        currentNativeType:
          type: string
          description: New data type of the column.
      title: ColumnNativeTypeChangeType
      additionalProperties: false
      description: ColumnNativeTypeChangeType represents a change in a column's data type.
    synq.entities.v1.SchemaColumnChange.ColumnRemovalChangeType:
      type: object
      properties:
        columnId:
          type: string
          description: Identifier of the removed column.
        nativeType:
          type: string
          description: Native data type of the removed column.
        ordinalPosition:
          type: integer
          format: int32
          description: Original position of the column in the schema.
      title: ColumnRemovalChangeType
      additionalProperties: false
      description: >-
        ColumnRemovalChangeType represents the removal of a column from the
        schema.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````