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

# ListSqlTests

> List SqlTests for given annotations.



## OpenAPI

````yaml /api-reference/openapi.yaml get /api/datachecks/sqltests/v1
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/datachecks/sqltests/v1:
    get:
      tags:
        - synq.datachecks.sqltests.v1.SqlTestsService
      summary: ListSqlTests
      description: List SqlTests for given annotations.
      operationId: synq.datachecks.sqltests.v1.SqlTestsService.ListSqlTests
      parameters:
        - name: annotations.name
          in: query
          description: String key for the annotation.
          required: true
          schema:
            type: string
            title: name
            maxLength: 50
            minLength: 1
            description: String key for the annotation.
        - name: annotations.values
          in: query
          description: Optional list of values that the annotation can carry.
          schema:
            type: array
            items:
              type: string
              maxLength: 50
              minLength: 1
              maxItems: 20
            title: values
            maxItems: 20
            description: Optional list of values that the annotation can carry.
        - name: integrationIds
          in: query
          schema:
            type: array
            items:
              type: string
            title: integration_ids
        - name: ids
          in: query
          schema:
            type: array
            items:
              type: string
            title: ids
        - name: configIds
          in: query
          schema:
            type: array
            items:
              type: string
              deprecated: true
            title: config_ids
            deprecated: true
        - name: configsFilter.ids
          in: query
          schema:
            type: array
            items:
              type: string
            title: ids
        - name: sources
          in: query
          schema:
            type: array
            items:
              $ref: '#/components/schemas/synq.v1.Source'
            title: sources
        - name: pagination.cursor
          in: query
          description: >-
            Opaque cursor token for the next page of results. If not provided,
            returns the first page.
             This is an encoded token that should be passed as-is from the previous PageInfo.last_id.
          schema:
            type: string
            title: cursor
            description: >-
              Opaque cursor token for the next page of results. If not provided,
              returns the first page.
               This is an encoded token that should be passed as-is from the previous PageInfo.last_id.
        - name: pagination.pageSize
          in: query
          description: >-
            Maximum number of items to return in a single page. If not provided,
            defaults vary per API.
          schema:
            type: integer
            title: page_size
            minimum: 0
            format: int32
            description: >-
              Maximum number of items to return in a single page. If not
              provided, defaults vary per API.
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/synq.datachecks.sqltests.v1.ListSqlTestsResponse
components:
  schemas:
    synq.v1.Source:
      type: string
      title: Source
      enum:
        - SOURCE_APP
        - SOURCE_API
    synq.datachecks.sqltests.v1.ListSqlTestsResponse:
      type: object
      properties:
        sqlTests:
          type: array
          items:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlTest'
        pageInfo:
          $ref: '#/components/schemas/synq.v1.PageInfo'
          description: Paging information
      title: ListSqlTestsResponse
      required:
        - pageInfo
      additionalProperties: false
    synq.datachecks.sqltests.v1.SqlTest:
      type: object
      properties:
        platform:
          $ref: '#/components/schemas/synq.platforms.v1.DataPlatformIdentifier'
          description: >-
            Identifier for the data platform which the SqlTest would be executed
            on.
        id:
          type: string
          description: >-
            Unique resource identifier for the SqlTest. This is externally
            maintained and can
             be used to fetch/update/delete this test.
        name:
          type: string
          description: Human friendly name.
        description:
          type: string
          description: Description of purpose and motivation.
        severity:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Severity'
        sqlExpression:
          type: string
          description: A valid SQL expression which is the test.
        recurrenceRule:
          type: string
          description: >-
            [Recurrence
            rule](https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html)
            for the execution schedule of the SqlTest.
        annotations:
          type: array
          items:
            $ref: '#/components/schemas/synq.entities.v1.Annotation'
          description: >-
            Annotations for the given SqlTest.These help filter the SqlTests for
            later
             operations like listing by API, selection in UI, analytics, etc.
        saveFailures:
          type: boolean
          description: Boolean flag to to toggle saving of failure runs.
        template:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Template'
          description: |-
            Template for the SqlTest.
             required when sql_expression is not provided
        configId:
          type: string
          description: Config ID for the SqlTest.
          nullable: true
        source:
          $ref: '#/components/schemas/synq.v1.Source'
        timezone:
          type: string
          description: |-
            IANA timezone name (e.g., "Europe/Prague", "America/New_York").
             Used to interpret the recurrence_rule in the given timezone.
             If empty, defaults to UTC.
        evaluators:
          type: array
          items:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Evaluator'
          description: >-
            Named evaluators attached to this test. Each evaluator has its own
            SQL
             boolean expression and severity. When present, the test outcome is
             determined by the worst severity among failing evaluators; tests with no
             evaluators fall back to the single-expression pass/fail rule.
        inputTables:
          type: array
          items:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.InputTable'
          description: Tables referenced by the SQL expression, resolved at upsert time.
      title: SqlTest
      required:
        - id
        - name
      additionalProperties: false
      description: >
        The SqlTest is a SQL test that is executed on a Coalesce Quality entity.

        sql_test_evaluator_ids_unique // evaluator ids must be unique within a
        SqlTest

        sql_test_requires_expression_or_suggestion // exactly one of
        sql_expression or template must be provided, but not both

        sql_test_requires_platform_or_template // at least one of platform or
        template identifier must be provided
    synq.v1.PageInfo:
      type: object
      properties:
        totalCount:
          type: integer
          format: int32
          description: >-
            Total number of items matching the request. May not be available for
            cursor-based pagination
             where the total is unknown or expensive to compute.
             Deprecated: most of the APIs which require pagination don't know the total count.
          deprecated: true
        count:
          type: integer
          format: int32
          description: Number of items returned in this response.
        lastId:
          type: string
          description: >-
            Opaque cursor token for fetching the next page of results. Pass this
            value as the cursor
             in the next Pagination request to continue pagination. Empty if there are no more pages.
      title: PageInfo
      additionalProperties: false
    synq.platforms.v1.DataPlatformIdentifier:
      type: object
      oneOf:
        - properties:
            athena:
              $ref: '#/components/schemas/synq.platforms.v1.AthenaIdentifier'
              title: athena
          title: athena
          required:
            - athena
        - properties:
            bigquery:
              $ref: '#/components/schemas/synq.platforms.v1.BigqueryIdentifier'
              title: bigquery
          title: bigquery
          required:
            - bigquery
        - properties:
            clickhouse:
              $ref: '#/components/schemas/synq.platforms.v1.ClickhouseIdentifier'
              title: clickhouse
          title: clickhouse
          required:
            - clickhouse
        - properties:
            databricks:
              $ref: '#/components/schemas/synq.platforms.v1.DatabricksIdentifier'
              title: databricks
          title: databricks
          required:
            - databricks
        - properties:
            dbtCloud:
              $ref: '#/components/schemas/synq.platforms.v1.DbtCloudIdentifier'
              title: dbt_cloud
          title: dbt_cloud
          required:
            - dbtCloud
        - properties:
            duckdb:
              $ref: '#/components/schemas/synq.platforms.v1.DuckDbIdentifier'
              title: duckdb
          title: duckdb
          required:
            - duckdb
        - properties:
            mssql:
              $ref: '#/components/schemas/synq.platforms.v1.MssqlIdentifier'
              title: mssql
          title: mssql
          required:
            - mssql
        - properties:
            mysql:
              $ref: '#/components/schemas/synq.platforms.v1.MysqlIdentifier'
              title: mysql
          title: mysql
          required:
            - mysql
        - properties:
            oracle:
              $ref: '#/components/schemas/synq.platforms.v1.OracleIdentifier'
              title: oracle
          title: oracle
          required:
            - oracle
        - properties:
            postgres:
              $ref: '#/components/schemas/synq.platforms.v1.PostgresIdentifier'
              title: postgres
          title: postgres
          required:
            - postgres
        - properties:
            redshift:
              $ref: '#/components/schemas/synq.platforms.v1.RedshiftIdentifier'
              title: redshift
          title: redshift
          required:
            - redshift
        - properties:
            snowflake:
              $ref: '#/components/schemas/synq.platforms.v1.SnowflakeIdentifier'
              title: snowflake
          title: snowflake
          required:
            - snowflake
        - properties:
            sqlMesh:
              $ref: '#/components/schemas/synq.platforms.v1.SqlMeshIdentifier'
              title: sql_mesh
          title: sql_mesh
          required:
            - sqlMesh
        - properties:
            synqIntegrationId:
              type: string
              title: synq_integration_id
              description: >-
                Coalesce Quality integration ID maps to the created integration
                on the Coalesce Quality platform.
          title: synq_integration_id
          required:
            - synqIntegrationId
        - properties:
            trino:
              $ref: '#/components/schemas/synq.platforms.v1.TrinoIdentifier'
              title: trino
          title: trino
          required:
            - trino
        - properties:
            unknown:
              $ref: '#/components/schemas/synq.platforms.v1.UnknownDataPlatform'
              title: unknown
          title: unknown
          required:
            - unknown
      additionalProperties: false
      description: >-
        DataPlatformIdentifier is a unique reference to a data platform
        integrated with Coalesce Quality.
    synq.datachecks.sqltests.v1.Severity:
      type: string
      title: Severity
      enum:
        - SEVERITY_UNSPECIFIED
        - SEVERITY_WARNING
        - SEVERITY_ERROR
        - SEVERITY_INFO
    synq.entities.v1.Annotation:
      type: object
      properties:
        name:
          type: string
          maxLength: 50
          minLength: 1
          description: String key for the annotation.
        values:
          type: array
          items:
            type: string
            maxLength: 50
            minLength: 1
            maxItems: 20
          maxItems: 20
          description: Optional list of values that the annotation can carry.
      title: Annotation
      required:
        - name
      additionalProperties: false
      description: |-
        Annotations can be used to annotate any entity with a key:value pair.
         These annotations can be used for filtering and searching entities.
    synq.datachecks.sqltests.v1.Template:
      type: object
      allOf:
        - properties:
            identifier:
              $ref: '#/components/schemas/synq.entities.v1.Identifier'
              title: identifier
              description: >-
                Read-only path of matched entity. This is a unique path that can
                be used to access the entity in the Coalesce Quality UI.
        - oneOf:
            - properties:
                acceptedValuesTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.AcceptedValuesTest
                  title: accepted_values_test
                  description: >-
                    Validates that column values are within an allowed set
                    (e.g., status in ['active', 'inactive', 'pending'])
              title: accepted_values_test
              required:
                - acceptedValuesTest
            - properties:
                businessQueryTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.BusinessQueryTest
                  title: business_query_test
                  description: >-
                    Full SELECT whose result rows are reported as failures;
                    supports
                     GROUP BY, JOINs, etc.
              title: business_query_test
              required:
                - businessQueryTest
            - properties:
                businessRuleTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.BusinessRuleTest
                  title: business_rule_test
                  description: >-
                    Per-row boolean predicate; rows matching are reported as
                    failures
                     (e.g., total_amount != subtotal + tax)
              title: business_rule_test
              required:
                - businessRuleTest
            - properties:
                emptyTest:
                  $ref: '#/components/schemas/synq.datachecks.sqltests.v1.EmptyTest'
                  title: empty_test
                  description: >-
                    Checks if specified columns contain empty values (e.g.,
                    description field can be empty)
              title: empty_test
              required:
                - emptyTest
            - properties:
                freshnessTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.FreshnessTest
                  title: freshness_test
                  description: >-
                    Checks if data is up-to-date based on a time column (e.g.,
                    latest event_timestamp within 24h)
              title: freshness_test
              required:
                - freshnessTest
            - properties:
                maxValueTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.MaxValueTest
                  title: max_value_test
                  description: >-
                    Validates numeric values are less than or equal to a maximum
                    value (e.g., price &lt;= 1000)
              title: max_value_test
              required:
                - maxValueTest
            - properties:
                minMaxTest:
                  $ref: '#/components/schemas/synq.datachecks.sqltests.v1.MinMaxTest'
                  title: min_max_test
                  description: >-
                    Validates numeric values are within specified range (e.g.,
                    price between 0 and 1000)
              title: min_max_test
              required:
                - minMaxTest
            - properties:
                minValueTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.MinValueTest
                  title: min_value_test
                  description: >-
                    Validates numeric values are greater than or equal to a
                    minimum value (e.g., price &gt;= 0)
              title: min_value_test
              required:
                - minValueTest
            - properties:
                notNullTest:
                  $ref: '#/components/schemas/synq.datachecks.sqltests.v1.NotNullTest'
                  title: not_null_test
                  description: >-
                    Checks if specified columns contain no NULL values (e.g.,
                    user_id should never be null)
              title: not_null_test
              required:
                - notNullTest
            - properties:
                rejectedValuesTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.RejectedValuesTest
                  title: rejected_values_test
                  description: >-
                    Validates that column values are not in a forbidden set
                    (e.g., country not in ['UNKNOWN', 'TEST'])
              title: rejected_values_test
              required:
                - rejectedValuesTest
            - properties:
                relationshipsTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.RelationshipsTest
                  title: relationships_test
                  description: >-
                    Validates referential integrity between source and reference
                    tables
              title: relationships_test
              required:
                - relationshipsTest
            - properties:
                relativeTimeTest:
                  $ref: >-
                    #/components/schemas/synq.datachecks.sqltests.v1.RelativeTimeTest
                  title: relative_time_test
                  description: >-
                    Compares time-based columns for logical order (e.g.,
                    start_date before end_date)
              title: relative_time_test
              required:
                - relativeTimeTest
            - properties:
                uniqueTest:
                  $ref: '#/components/schemas/synq.datachecks.sqltests.v1.UniqueTest'
                  title: unique_test
                  description: >-
                    Ensures specified columns form a unique key combination
                    (e.g., order_id is unique)
              title: unique_test
              required:
                - uniqueTest
      title: Template
      required:
        - identifier
      additionalProperties: false
    synq.datachecks.sqltests.v1.Evaluator:
      type: object
      properties:
        id:
          type: string
          pattern: ^[A-Za-z0-9_-]+$
          description: >-
            Stable identifier for the evaluator, unique within the parent
            SqlTest.
             Must contain only ASCII letters, digits, hyphens, or underscores.
        name:
          type: string
          description: Human friendly name.
        sqlExpression:
          type: string
          description: >-
            SQL expression evaluated against the test rows. The expression is a
            FAIL
             condition: a row is flagged when the expression evaluates to TRUE. NULL
             evaluates as pass (equivalent to FALSE).
        severity:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Severity'
          description: >-
            Severity routed to alerting when this evaluator fails. Defaults to
            the
             parent SqlTest severity when left unspecified.
      title: Evaluator
      required:
        - id
        - name
        - sqlExpression
      additionalProperties: false
      description: |-
        Evaluator is a named condition attached to a SqlTest that produces
         an independent pass/fail signal. A single SqlTest may carry multiple
         evaluators, each targeting a different concern (nullability, value
         ranges, row counts, etc.).
    synq.datachecks.sqltests.v1.InputTable:
      type: object
      properties:
        fqn:
          $ref: '#/components/schemas/synq.ingest.dwh.v1.Fqn'
          description: Fully-qualified name of the referenced table.
        tablePath:
          type: string
          description: >-
            Synq-internal path for the table asset (e.g.
            "bq-prod::project::dataset::table").
      title: InputTable
      additionalProperties: false
      description: >-
        InputTable is a table reference resolved from the SQL expression of a
        SqlTest.
    synq.platforms.v1.AthenaIdentifier:
      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
             by SYNQ 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.
      title: AthenaIdentifier
      required:
        - instance
        - catalog
      additionalProperties: false
    synq.platforms.v1.BigqueryIdentifier:
      type: object
      properties:
        project:
          type: string
          description: BigQuery project
      title: BigqueryIdentifier
      required:
        - project
      additionalProperties: false
    synq.platforms.v1.ClickhouseIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Clickhouse host inclusive of port
        schema:
          type: string
          description: Clickhouse database
      title: ClickhouseIdentifier
      required:
        - host
        - schema
      additionalProperties: false
    synq.platforms.v1.DatabricksIdentifier:
      type: object
      properties:
        workspace:
          type: string
          description: URL of the databricks workspace
      title: DatabricksIdentifier
      required:
        - workspace
      additionalProperties: false
    synq.platforms.v1.DbtCloudIdentifier:
      type: object
      properties:
        apiEndpoint:
          type: string
          description: API endpoint for Dbt Cloud
        accountId:
          type: string
          description: Account ID
        projectId:
          type: string
          description: Project ID
      title: DbtCloudIdentifier
      required:
        - apiEndpoint
        - accountId
        - projectId
      additionalProperties: false
    synq.platforms.v1.DuckDbIdentifier:
      type: object
      properties:
        motherduckAccount:
          type: string
      title: DuckDbIdentifier
      additionalProperties: false
    synq.platforms.v1.MssqlIdentifier:
      type: object
      properties:
        host:
          type: string
          description: SQL Server host
        database:
          type: string
          description: Database name
      title: MssqlIdentifier
      required:
        - host
        - database
      additionalProperties: false
    synq.platforms.v1.MysqlIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Mysql host inclusive of port
      title: MysqlIdentifier
      required:
        - host
      additionalProperties: false
    synq.platforms.v1.OracleIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Oracle host
        serviceName:
          type: string
          description: Oracle service name (PDB)
      title: OracleIdentifier
      required:
        - host
        - serviceName
      additionalProperties: false
    synq.platforms.v1.PostgresIdentifier:
      type: object
      properties:
        host:
          type: string
          description: Postgres host inclusive of port
        database:
          type: string
          description: Postgres database
      title: PostgresIdentifier
      required:
        - host
        - database
      additionalProperties: false
    synq.platforms.v1.RedshiftIdentifier:
      type: object
      properties:
        cluster:
          type: string
          description: Redshift cluster
        database:
          type: string
          description: Redshift database
      title: RedshiftIdentifier
      required:
        - cluster
        - database
      additionalProperties: false
    synq.platforms.v1.SnowflakeIdentifier:
      type: object
      properties:
        account:
          type: string
          description: Snowflake account
        database:
          type: string
          description: Snowflake database
      title: SnowflakeIdentifier
      required:
        - account
        - database
      additionalProperties: false
    synq.platforms.v1.SqlMeshIdentifier:
      type: object
      properties:
        defaultDatabaseInstance:
          type: string
          description: Default database instance for SQL Mesh
      title: SqlMeshIdentifier
      required:
        - defaultDatabaseInstance
      additionalProperties: false
    synq.platforms.v1.TrinoIdentifier:
      type: object
      properties:
        coordinator:
          type: string
      title: TrinoIdentifier
      additionalProperties: false
    synq.platforms.v1.UnknownDataPlatform:
      type: object
      title: UnknownDataPlatform
      additionalProperties: false
    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.
    synq.datachecks.sqltests.v1.AcceptedValuesTest:
      type: object
      properties:
        columnName:
          type: string
          description: Name of the column to validate
        acceptedValues:
          type: array
          items:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlValue'
          minItems: 1
          description: List of allowed values for the column
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: AcceptedValuesTest
      required:
        - columnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.BusinessQueryTest:
      type: object
      properties:
        sqlQuery:
          type: string
          description: |-
            Full SELECT statement. Result rows are reported as failures.

             Format: a single SELECT (CTEs allowed); no semicolon. May read any tables
             the integration has access to. The engine wraps it as
             `WITH raw_query AS (<sql_query>) SELECT * FROM raw_query`.

             Use this when the failure set requires GROUP BY, JOINs, window functions,
             or other shape that a per-row predicate (BusinessRuleTest) cannot express.

             Example:
               SELECT customer_id, SUM(amount) AS total
               FROM orders WHERE status = 'paid'
               GROUP BY customer_id HAVING SUM(amount) < 0

             Template.identifier still anchors the test to a primary table for
             ownership, alerts, and UI grouping.

             Note: this test does not expose a `select_columns` option. The author
             controls the SELECT shape directly in `sql_query`.
      title: BusinessQueryTest
      required:
        - sqlQuery
      additionalProperties: false
    synq.datachecks.sqltests.v1.BusinessRuleTest:
      type: object
      properties:
        sqlExpression:
          type: string
          description: |-
            Boolean SQL predicate evaluated per row of the anchor table
             (Template.identifier); rows where the predicate is TRUE are reported as
             failures.

             Format: a single boolean expression — no SELECT, WITH, or semicolons.
             References columns on the anchor table. The engine executes it as
             `SELECT * FROM <anchor_table> WHERE <sql_expression>`.

             Example: "total_amount != subtotal + tax" reports rows where totals
             disagree. Use BusinessQueryTest for SELECT / GROUP BY / multi-table logic.
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: BusinessRuleTest
      required:
        - sqlExpression
      additionalProperties: false
    synq.datachecks.sqltests.v1.EmptyTest:
      type: object
      properties:
        columnNames:
          type: array
          items:
            type: string
            minItems: 1
            uniqueItems: true
          minItems: 1
          uniqueItems: true
          description: List of column names to check for empty values
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: EmptyTest
      additionalProperties: false
    synq.datachecks.sqltests.v1.FreshnessTest:
      type: object
      properties:
        timePartitionColumnName:
          type: string
          description: Name of the timestamp column used for freshness check
        timeWindowSeconds:
          type:
            - integer
            - string
          format: int64
          description: Time window for freshness check (in seconds)
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: FreshnessTest
      required:
        - timePartitionColumnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.MaxValueTest:
      type: object
      properties:
        columnName:
          type: string
          description: Name of the numeric column to validate
        maxValue:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlValue'
          description: Maximum allowed value (inclusive)
        strictly:
          type: boolean
          description: If true, the maximum value is exclusive
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: MaxValueTest
      required:
        - columnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.MinMaxTest:
      type: object
      properties:
        columnName:
          type: string
          description: Name of the numeric column to validate
        minValue:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlValue'
          description: Minimum allowed value (inclusive)
        maxValue:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlValue'
          description: Maximum allowed value (inclusive)
        strictly:
          type: boolean
          description: If true, bounds are exclusive
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: MinMaxTest
      required:
        - columnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.MinValueTest:
      type: object
      properties:
        columnName:
          type: string
          description: Name of the numeric column to validate
        minValue:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlValue'
          description: Minimum allowed value (inclusive)
        strictly:
          type: boolean
          description: If true, the minimum value is exclusive
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: MinValueTest
      required:
        - columnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.NotNullTest:
      type: object
      properties:
        columnNames:
          type: array
          items:
            type: string
            minItems: 1
            uniqueItems: true
          minItems: 1
          uniqueItems: true
          description: List of column names to check for NULL values
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: NotNullTest
      additionalProperties: false
    synq.datachecks.sqltests.v1.RejectedValuesTest:
      type: object
      properties:
        columnName:
          type: string
          description: Name of the column to validate
        rejectedValues:
          type: array
          items:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlValue'
          minItems: 1
          description: List of disallowed values for the column
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: RejectedValuesTest
      required:
        - columnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.RelationshipsTest:
      type: object
      properties:
        references:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.RelationshipReference
          minItems: 1
          description: List of reference table relationships to check
        ignoreNulls:
          type: boolean
          description: >-
            If true, source rows where all join columns are NULL are excluded
            from results
        timePartitionColumn:
          type: string
          description: Column name used to filter source rows by time (e.g., "created_at")
        timeWindowSeconds:
          type:
            - integer
            - string
          format: int64
          description: Time window in seconds - only check source rows within this window
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: RelationshipsTest
      additionalProperties: false
    synq.datachecks.sqltests.v1.RelativeTimeTest:
      type: object
      properties:
        columnName:
          type: string
          description: Name of the first time column to compare
        relativeColumnName:
          type: string
          description: Name of the second time column that should be later than the first
        selectColumns:
          type: array
          items:
            type: string
            uniqueItems: true
          uniqueItems: true
          description: >-
            Optional list of columns to include in the SELECT clause of the
            generated SQL.
             When empty (default), SELECT * is used — all columns are returned.
      title: RelativeTimeTest
      required:
        - columnName
        - relativeColumnName
      additionalProperties: false
    synq.datachecks.sqltests.v1.UniqueTest:
      type: object
      properties:
        columnNames:
          type: array
          items:
            type: string
            minItems: 1
            uniqueItems: true
          minItems: 1
          uniqueItems: true
          description: List of columns that should form a unique combination
        timePartitionColumnName:
          type: string
          description: >-
            If provided, the check will be applied to the time window of the
            time partition column
             If not provided, the check will be applied to all rows
        timeWindowSeconds:
          type:
            - integer
            - string
          format: int64
          description: Time window for uniqueness check (in seconds)
      title: UniqueTest
      additionalProperties: false
      description: >-
        Note: this test does not expose a `select_columns` option. The SELECT
        shape
         is fixed by the aggregation (DISTINCT columns + duplicate count); failure
         rows are the duplicate keys, not raw table rows.
    synq.ingest.dwh.v1.Fqn:
      type: object
      properties:
        instanceName:
          type: string
        databaseName:
          type: string
        schemaName:
          type: string
        objectName:
          type: string
      title: Fqn
      required:
        - objectName
      additionalProperties: false
    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.datachecks.sqltests.v1.SqlValue:
      type: object
      allOf:
        - oneOf:
            - required:
                - stringLiteral
            - required:
                - expression
      properties:
        stringLiteral:
          type: string
          description: >-
            Literal value that should be quoted in SQL (e.g., '2025-05-12',
            'active')
        expression:
          type: string
          description: >-
            SQL expression, numbers to be used as plain text (e.g., NOW(),
            COUNT(*), true, 1.1)
      title: SqlValue
      additionalProperties: false
      description: >-
        Represents a value that can be either a literal (to be quoted in SQL) or
        a SQL expression (to be used as plain text).
    synq.datachecks.sqltests.v1.RelationshipReference:
      type: object
      properties:
        entity:
          $ref: '#/components/schemas/synq.entities.v1.Identifier'
          description: The reference entity (table to check foreign keys against)
        columns:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.RelationshipColumn
          minItems: 1
          description: Column mappings between source and reference tables
      title: RelationshipReference
      required:
        - entity
      additionalProperties: false
    synq.datachecks.sqltests.v1.RelationshipColumn:
      type: object
      properties:
        source:
          type: string
          description: Column name in the source table
        reference:
          type: string
          description: Column name in the reference table
      title: RelationshipColumn
      required:
        - source
        - reference
      additionalProperties: false
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````