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

# GetSqlTestDeployOverview

> Preview the effect of deploying a rule (which have not yet been saved), without
 deploying it.



## OpenAPI

````yaml /api-reference/openapi.yaml get /api/datachecks/sql-test-deployment-rules/v1/overview
openapi: 3.1.0
info:
  version: '1.0'
  title: SYNQ
servers:
  - url: https://developer.synq.io
  - url: https://api.us.synq.io
  - url: https://api.au.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.git.commits.v1.CommitsService
  - name: synq.recommendations.v1.RecommendationsService
    description: |-
      RecommendationsService lists the changes Coalesce Quality recommends you
       make, and records what you decided about them. See `Recommendation` for
       what a recommendation is.

       Recommendations are created and removed by Coalesce Quality itself: one
       appears when something only you can change is found, and disappears once
       it no longer holds. What you can do is decide whether a recommendation
       stays in front of you:

         - Dismiss hides it until something new is found about it: an object it
           did not list before, or a different remediation.
         - Ignore hides it for good.
         - Restore undoes either.

       Decisions are kept by recommendation id, so they keep applying when a
       recommendation disappears and comes back.

       A recommendation about an integration is also governed by that
       integration's permissions: reading it needs a credential that can read
       integrations, and deciding about it one that can edit them. One that cannot
       does not see it listed.

       Related services: `synq.integrations.v1.IntegrationsService` manages the
       integrations recommendations can be about.
  - name: synq.monitors.custom_monitors.v1.CustomMonitorsService
  - name: synq.monitors.info.v1.MonitorInfoService
  - name: synq.monitors.automated_monitors.v1.DeploymentRulesService
  - name: synq.monitors.segments.v1.MonitorSegmentsService
    description: |-
      Reads and names the segments of a segmented custom monitor.

       A monitor configured with a segmentation expression splits the data it
       monitors into one time series per distinct value of that expression, and each
       of those is a segment. The label is what every downstream surface shows for a
       segment: the name of the check it produces, the search result, the alert. A
       segment with no label falls back to its raw value, so a monitor segmented on
       something encoded (an id, a code, a hashed bucket) reads as that raw value
       everywhere until the segment is named.
  - name: synq.monitors.history.v1.HistoryService
  - name: synq.monitors.predictions.v1.MonitorPredictionsService
    description: Access to anomaly detection model predictions and raw metric timeseries.
  - name: synq.schedule.v1.ScheduleService
    description: ScheduleService provides schedule evaluation utilities.
  - name: synq.extensions.atlan.integrations.v1.AtlanIntegrationService
  - name: synq.extensions.atlan.provider.v1.AtlanProviderService
  - name: synq.extensions.atlan.workflows.v1.AtlanWorkflowService
  - name: synq.alerts.services.v2.AlertsService
    description: |-
      AlertsService provides operations for managing alert configurations.

       It supersedes synq.alerts.services.v1.AlertsService: entities are selected with
       the canonical synq.queries.v1.Query + resolver_ql trigger rather than the bespoke
       EntityGroupQuery.
  - name: synq.alerts.services.v1.AlertsService
    description: |-
      AlertsService provides operations for managing alert configurations.

       Deprecated: use synq.alerts.services.v2.AlertsService. The v2 service selects
       entities with the canonical synq.queries.v1.Query + resolver_ql trigger; this
       v1 service, which uses the bespoke EntityGroupQuery selection, is scheduled for
       removal. Migrate existing integrations to v2.
  - name: synq.domains.v2.DomainsService
    description: >-
      DomainsService manages data domains — named areas of ownership that group
      the
       assets, data products and sub-domains belonging to one part of the business.

       Ids are opaque UUIDs supplied by the caller, which makes writes idempotent
       (a retried create converges instead of duplicating). Mutable fields are
       optional on Upsert: a field that is set is written, a field that is omitted is
       left unchanged. Pass the `etag` you last read to guard against overwriting a
       concurrent edit.

       A domain may contain other domains and data products, so membership resolution
       is recursive. Every write that adds such a reference — including a change of
       `parent_id` — is rejected if it would close a loop, so a definition can always
       be resolved in finite time.
  - name: synq.domains.members.v1.DomainMembersService
    description: DomainMembersService can be used to manage domain memberships.
  - name: synq.domains.v1.DomainsService
    description: DomainsService can be used to manage domains.
  - name: synq.queries.v1.QueriesService
    description: |-
      QueriesService compiles and evaluates ResolverQL — the compact text query
       language used across Coalesce Quality to select entities — over the public
       API.

       ResolverQL is a string DSL (for example `with_type("TABLE")` or
       `in_folder(...)`); a structured `synq.queries.v1.Query` is its parsed,
       machine-readable form. This service is the bridge between the two and the
       read-only execution surface for both:
         - `TranslateResolverQl` compiles a ResolverQL expression into a structured
           `Query` without evaluating it — inspect it, validate it, or reuse it as a
           filter on another API (entity listing, folder browsing, ...).
         - `ResolveQuery` compiles a ResolverQL expression (or takes an
           already-structured `Query`), evaluates it against the catalog, and
           returns the matched entity ids. This is the general author -> resolve
           loop.
         - `DescribeResolverQl` returns the language itself — every function, every
           accepted enum value — so you author against what this deployment compiles
           rather than against a table baked into your client.

       All three authenticate and resolve your workspace from your credentials.
       `DescribeResolverQl` additionally needs no permission of its own, so any
       credential can read it; the other two read the catalog and are scoped.
  - name: synq.queries.v1.NLQueryService
    description: >-
      NLQueryService generates structured Query protos from natural language
      descriptions using an LLM.
  - name: synq.incidents.v1.IncidentsService
    description: IncidentsService is a service for managing Incidents.
  - name: synq.overlays.v1.OverlaysService
    description: |-
      OverlaysService answers which organizational overlays claim an entity.

       An overlay is a grouping you lay over your catalog rather than something the
       warehouse itself knows about. Two kinds exist today: a **data product**, which
       groups the assets that make up something your organization delivers, and an
       **owner**, which names the person or team responsible for a set of assets and
       where alerts about them go. Each is defined by a membership rule, not by an
       explicit list, so what belongs to one changes as your warehouse does.

       "Owner" here means stewardship — who is accountable for an asset and who hears
       about it when something breaks. It is not the structural containment sense the
       word carries elsewhere in the API, where an asset can be said to own the checks
       and monitors declared on it. Nothing this service returns describes that
       relationship.

       This service reads that membership backwards. The defining services answer
       "what is in this data product"; this one answers "which data products and
       owners claim this table" — the question you have when you are looking at one
       asset and want to know who cares about it and what it feeds.

       Membership follows identity. Where the same table is represented more than
       once in your catalog — a transformation model and the warehouse table it
       builds — an overlay whose rule matches one of them claims the others too. So
       an alert routed by ownership reaches the responsible party whichever
       representation raised it, and you do not have to know which one a rule was
       written against.

       Two consequences worth planning around. You can ask about whichever
       representation you happen to hold and get the same answer, so there is no need
       to resolve an identity group first. And if you do ask about several members of
       one group in a single call, each comes back with its own entry carrying the
       same overlays — correct, but redundant, so ask about one member per group when
       you are near the request limit.

       Related services:
         - `synq.dataproducts.v2.DataproductsService` and `synq.owners.v1.OwnersService`
           define the overlays read here, and turn an id from a response into a name,
           a description and its contact channels.
         - `synq.entities.resolve.v1.IdentifierResolveService` turns an identifier you
           already hold — a warehouse table name, a dbt model — into the `entity_id`
           these calls take.
  - 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.platforms.v1.PlatformsService
    description: PlatformsService is a service for managing Platforms and Integrations.
  - name: synq.deliveries.v1.DeliveriesService
    description: >-
      DeliveriesService reports what was sent to your notification integrations
      —
       webhooks, PagerDuty, Opsgenie — and what came back.

       It answers the three questions an integration owner has. "Did this event
       reach my endpoint": list the deliveries for an event id and read the outcome
       of each. "Why did my endpoint reject it": read the attempts, which carry the
       request as it was sent and the response as it came back. "Why did I get
       nothing at all": every delivery that sent nothing records a reason, so a
       silent integration can be explained rather than guessed at.

       Deliveries are kept for 90 days. Credential-bearing header values are never
       returned, on either side of an attempt — see `Header`.
  - name: synq.agent.sre.v1.LlmService
    description: Service for evaluating LLM requests and producing structured output.
  - 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.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.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.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.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.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.ChecksRelationshipsService
  - 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.EntityExecutionsService
  - name: synq.entities.custom.v1.TypesService
    description: TypesService is a service for managing custom entity types.
  - name: synq.entities.custom.v1.FeaturesService
  - 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.folders.v1.FoldersService
    description: >-
      FoldersService discovers and browses the folder / containment hierarchy of
      the
       catalog: the roots data hangs from, the sub-folders under any folder, the
       folders a given entity lives in, and the entities contained in a folder.

       It is a read / navigation surface, not folder management — there are no
       create, move, or delete operations.

       Addressing: every folder has an opaque `folder_entity_id` (round-trip it
       verbatim) and a structured `FolderRef{root_entity_id, folders[]}` (the
       human-friendly form). Entities — both folder members and the ids you pass to
       `GetFolderOf` — are named by their opaque entity id, the same id used across
       the rest of the entities API.

       Depth footgun: membership is SHALLOW by default. `Browse` returns only the
       direct children of a folder, and `ListMembers` returns only the entities
       placed directly in the folder. Set `deep = true` (or raise `Browse.depth`) to
       recurse into sub-folders.
  - 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.status.v1.EntityIssuesService
    description: EntityIssuesService is the service which retrieves entity issues status.
  - name: synq.entities.status.v1.EntityIncidentsService
    description: EntityIncidentsService is the service which retrieves entity status.
  - name: synq.entities.impact.v1.ImpactService
  - name: synq.entities.coordinates.v1.DatabaseCoordinatesService
    description: >-
      DatabaseCoordinatesService is a service for getting database coordinates
      of Entities.
  - name: synq.entities.activity.v1alpha.ActivityService
    description: >-
      ActivityService reads the query history of a workspace's data platforms:
      how popular an entity is,
       who reads and writes it, what one login, tool, job or person touched and what it cost, and where a
       workspace's compute goes.

       Every read covers a window of whole UTC hours, by default the 30 days before the current hour. A
       login's reads count toward popularity as its service account's popularity policy says (see
       synq.entities.platformusers.v1alpha.ServiceAccountsService), and Coalesce Quality's own queries never
       count.

       Weights are per query, in each platform's own figures. bytes_scanned is never a cost, and no
       platform reports cost per table, so an entity's share of a query is an equal split. Nothing here is
       credits or currency.
  - name: synq.entities.orchestration.v1.OrchestrationService
    description: >-
      OrchestrationService tells which jobs, job steps and tasks run an entity,
      and which entities a
       job, job step or task runs, from the runs of the last 31 days. It covers Airflow tasks and DAGs,
       dbt Cloud job steps and Coalesce jobs.

       Deprecated: use synq.entities.activity.v1alpha.ActivityService. BatchGetEntityUsage answers "what
       runs this" for a table or a model, as its ORCHESTRATED and TRANSFORMED roles, and GetActorSummary
       answers "what this job runs", from its RUNS writes.
  - name: synq.entities.checks.v2.ChecksCategoriesService
    description: |-
      ChecksCategoriesService reads and edits the categories of the checks in a
       workspace.

       Categorising checks is what turns a long list of tests into a picture of data
       quality: it lets you ask how much of a data product is covered for
       completeness, or which freshness checks exist across three warehouses that
       each name the same idea differently.

       Every check resolves to at most one category per dimension:

         * technical — what kind of check this is, mechanically ("nullness",
           "uniqueness", "freshness");
         * governance — what the check is for, in data-quality terms
           ("Completeness", "Accuracy", "Timeliness").

       The two are independent, and each resolves from three sources, in descending
       precedence: a category set explicitly on the check through this service, a
       category the producing tool declared, and a category one of the workspace's
       categorisation rules computed. Rules are managed by
       ChecksCategorisationRulesService and are the right tool for anything that
       generalises; set a category explicitly only for the checks that are genuine
       exceptions.

       The workspace and the acting identity always come from the request
       credentials, never from the payload.
  - name: synq.entities.checks.v2.ChecksCategorisationRulesService
    description: |-
      ChecksCategorisationRulesService manages the rules that categorise a
       workspace's checks automatically.

       A rule says "checks matching this predicate get this category on this
       dimension". Rules are the scalable way to categorise: they apply to checks
       that already exist and to every check ingested afterwards, so a new dbt
       package or a new warehouse does not mean a fresh round of manual tagging. A
       rule-computed category is the lowest-precedence source — a category set
       explicitly on a check through ChecksCategoriesService, and one the producing
       tool declared, both win over it.

       A typical loop is: ListCategorisationFilters to see what the workspace's
       checks look like, PreviewRule to check the reach of a candidate, UpsertRule
       to save it, then GetRecategorisationStatus to confirm the existing checks
       have caught up.

       Every workspace starts with a set of platform-provided rules covering the
       common cases. They are visible here, they can be superseded by a workspace
       rule of any priority, and they cannot be edited from a workspace.
  - 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.platformusers.v1alpha.PlatformUsersService
    description: >-
      PlatformUsersService reads the logins of a workspace's data platforms, as
      its integrations declare
       them and as their queries show them: how each login reads, why, how much it does and what it costs.

       Logins, their emails and what they read are often personal data, so every read here needs the
       platform users scope, which a Developer and an Admin have.
  - name: synq.entities.platformusers.v1alpha.ServiceAccountsService
    description: >-
      ServiceAccountsService maintains a workspace's service accounts, person
      links and popularity
       policies: which logins act for a tool, which belong to a person, and whose reads count toward an
       entity's popularity.

       Every change goes through a plan first. A typical loop is: ListPlatformUsers with unclassified_only
       to see the logins nothing classifies, ListServiceAccountSuggestions for the accounts their evidence
       points at, PlanServiceAccountChanges to see what a change set moves, then
       ApplyServiceAccountChanges with the plan's token. A change takes effect on the next read.

       Exact matchers, suggestion evidence and plans name logins, which are often personal data. A caller
       without the platform users scope gets them with every platform user id, login and person identity
       cleared, and the counts kept. A suggestion's account name and login patterns come from the logins it
       saw, so that caller gets those cleared too, and a suggestion named after its one login is named
       "Service login".
  - 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 by how many entities", "what SQL constructs does
       this specific entity use" and "which columns does building this entity join
       on", without requiring the caller to re-parse any SQL.
  - name: synq.entities.entities.v1.EntitiesService
    description: EntitiesService is a service for retriving any entity.
  - name: synq.entities.resolve.v1.IdentifierResolveService
    description: >-
      IdentifierResolveService resolves identifiers to their Coalesce Quality
      paths and identities.
  - 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.typedefs.v1.TypeDefsService
    description: >-
      TypeDefsService tells you what the type values in every other endpoint
      mean.

       Responses across the API describe things by enum — an entity is an
       `ENTITY_TYPE_BQ_TABLE`, it belongs to `DATA_PLATFORM_TYPE_BIGQUERY`, a run is an
       `EXECUTION_TYPE_DBT_INVOCATION`. This service turns each of those into a name you
       can display and a set of facts you can act on: is this a transformation model,
       does it live in a warehouse, can it be monitored.

       Read it instead of keeping your own copy of the list. New entity types and new
       platforms are added as Coalesce Quality supports more tools, and a hard-coded
       table in your code will label them with whatever its fallback produces and miss
       that an existing type gained a capability. Everything here comes from the server,
       so you pick both up without changing your code.

       A typical integration calls them once at startup, keeps them in a map, and looks
       types up as responses arrive.

       It also tells you what a selection query can ask for: ListEntityTraitDefs is the
       vocabulary behind `traits`, which selects entities by what they are rather than
       by naming every type.

       Scoping and freshness:

         * ListEntityTypeDefs is per workspace, because the types you defined yourself
           are part of your workspace's vocabulary. It returns the built-in types and
           your own custom types together.
         * ListPlatformDefs, ListExecutionTypeDefs and ListEntityTraitDefs are the same
           for everyone.
         * The built-in half changes only when Coalesce Quality is upgraded, so caching
           it for the life of your process is fine. You can add or edit your own custom
           types at any time, so if a newly created type needs to appear promptly, cache
           the entity types for minutes rather than hours, or re-read after you change
           one.

       The workspace comes from your credentials; there is nothing to pass.

       Each list is small — hundreds of entries — so every call returns the whole set
       and none of them page.
  - 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.entities.executions.v1.EntityExecutionsService
    description: 'Deprecated: Use [synq.entities.custom.v1.EntityExecutionsService] instead'
  - name: synq.entities.lineage.folds.v1alpha.LineageFoldsService
    description: >-
      LineageFoldsService manages the lineage folds of a workspace: rules that
      show
       many similar entities, a table or a storage path written anew on every run,
       as one node in lineage. See `LineageFold`.

       A change to a fold reaches lineage shortly after the call returns, not
       within it.

       Fold ids are UUIDs chosen by the caller, so a retried create converges on
       the same fold instead of making a second one. Pass the `etag` you last read
       on a change to guard against overwriting a concurrent edit.

       This API is in alpha: its shape may change without notice.
  - 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.users.v1.UsersService
  - 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.auth.iam.v1.IamService
  - name: synq.knowledge.v1alpha.KnowledgeService
    description: >-
      KnowledgeService reads the knowledge a team keeps about its data:
      knowledge
       pages written or imported by the team, and the descriptions people write for
       entities.

       Knowledge pages form a tree, and pages and entities are pinned to each
       other. Nothing here is the description an entity's own source reports, which
       `synq.entities.entities.v1.EntitiesService` reads.

       This API is in alpha: its shape may change without notice.
  - name: synq.dataproducts.v2.DataproductsService
    description: |-
      DataproductsService manages data products — named, owned groupings of data
       assets with a membership definition, a priority and an optional folder.

       Ids are opaque UUIDs supplied by the caller, which makes writes idempotent
       (a retried create converges instead of duplicating). Mutable fields are
       optional on Upsert: a field that is set is written, a field that is omitted is
       left unchanged. Pass the `etag` you last read to guard against overwriting a
       concurrent edit.

       A data product is a leaf in the reference graph — its definition may not
       reference another data product or domain — so membership resolution always
       terminates.
  - name: synq.dataproducts.v1.DataproductsService
    description: DataproductsService can be used to manage data products.
  - name: synq.owners.v1.OwnersService
    description: |-
      OwnersService manages owners and their ownerships — the "alert routing as
       code" surface. An owner is a named responsible party with notification
       channels (contacts); an ownership assigns a set of assets to an owner and
       configures the alerts routed to it. Owner is the resource, ownership its
       sub-resource: an ownership is meaningless without its owner, and deleting an
       owner deletes its ownerships.

       Ids are opaque UUIDs supplied by the caller, which makes writes idempotent (a
       retried create converges instead of duplicating). Mutable fields are optional
       on the Upsert calls: a set field is written, an omitted field is left
       unchanged. Pass the `etag` you last read to guard against overwriting a
       concurrent edit.

       Related: `synq.dataproducts.v2.DataproductsService` (an ownership can own a
       whole data product), `synq.alerts.services.v2.AlertsService` (how the configured alerts
       are reported), and `synq.users.v1.UsersService` (resolve the users behind
       `UserContact` and Slack/Teams mentions).
  - name: synq.ingest.cloudwatch.v1.CloudwatchService
  - name: synq.ingest.dwh.v1.DwhService
  - name: synq.ingest.airflow.v1.AirflowLogsService
  - name: synq.ingest.openlineage.v1.OpenlineageService
  - name: synq.datachecks.v1.TriggerService
    description: TriggerService provides synchronous execution of datachecks on entities.
  - name: synq.datachecks.sqltests.v1.SqlTestsService
    description: SqlTestsService is a service for managing SqlTests.
  - name: synq.datachecks.sqltests.v1.SqlTestsDeploymentRulesService
    description: |-
      SqlTestsDeploymentRulesService manages SqlTestDeploymentRules — rules that
       dynamically deploy SQL test templates onto every table or view a query
       matches, resyncing over time as the match set changes.
  - name: synq.datachecks.testsuggestions.v1.TestSuggestionsService
paths:
  /api/datachecks/sql-test-deployment-rules/v1/overview:
    get:
      tags:
        - synq.datachecks.sqltests.v1.SqlTestsDeploymentRulesService
      summary: GetSqlTestDeployOverview
      description: >-
        Preview the effect of deploying a rule (which have not yet been saved),
        without
         deploying it.
      operationId: >-
        synq.datachecks.sqltests.v1.SqlTestsDeploymentRulesService.GetSqlTestDeployOverview
      parameters:
        - name: deploymentRule.id
          in: query
          description: Unique identifier for this rule.
          schema:
            type: string
            title: id
            format: uuid
            description: Unique identifier for this rule.
        - name: deploymentRule.title
          in: query
          description: Human friendly name for this rule.
          schema:
            type: string
            title: title
            maxLength: 100
            minLength: 1
            description: Human friendly name for this rule.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.entityId
          in: query
          description: >-
            Opaque id of the entity, set on every identifier the API returns.
            Round-trip
             it verbatim; the format is not part of this contract and may change, and it
             is never constructed by hand.

             OUTPUT ONLY. On a request this field is ignored — the structured variant is
             what resolves. That is what lets you hand an identifier straight back
             unchanged, or edit its structured fields, without the two disagreeing about
             which entity you meant. To name an entity BY opaque id on a request, set the
             `synq_path` variant to that id: it carries exactly this string, and it is
             also how an entity whose platform has no structured variant is named.
          schema:
            type: string
            title: entity_id
            maxLength: 1024
            description: >-
              Opaque id of the entity, set on every identifier the API returns.
              Round-trip
               it verbatim; the format is not part of this contract and may change, and it
               is never constructed by hand.

               OUTPUT ONLY. On a request this field is ignored — the structured variant is
               what resolves. That is what lets you hand an identifier straight back
               unchanged, or edit its structured fields, without the two disagreeing about
               which entity you meant. To name an entity BY opaque id on a request, set the
               `synq_path` variant to that id: it carries exactly this string, and it is
               also how an entity whose platform has no structured variant is named.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.dbtCoreNode.integrationId
          in: query
          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.
          required: true
          schema:
            type: string
            title: integration_id
            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.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.dbtCoreNode.nodeId
          in: query
          description: Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)
          required: true
          schema:
            type: string
            title: node_id
            description: >-
              Dbt node_id that identifies one of dbt DAG nodes (model, test,
              etc)
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.dbtCloudNode.projectId
          in: query
          description: Your dbt Cloud project id
          required: true
          schema:
            type: string
            title: project_id
            description: Your dbt Cloud project id
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.dbtCloudNode.accountId
          in: query
          description: Your dbt Cloud account id
          schema:
            type: string
            title: account_id
            description: Your dbt Cloud account id
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.dbtCloudNode.nodeId
          in: query
          description: Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)
          required: true
          schema:
            type: string
            title: node_id
            description: >-
              Dbt node_id that identifies one of dbt DAG nodes (model, test,
              etc)
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.bigqueryTable.project
          in: query
          description: BigQuery project
          required: true
          schema:
            type: string
            title: project
            description: BigQuery project
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.bigqueryTable.dataset
          in: query
          description: BigQuery dataset id
          required: true
          schema:
            type: string
            title: dataset
            description: BigQuery dataset id
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.bigqueryTable.table
          in: query
          description: BigQuery table name
          required: true
          schema:
            type: string
            title: table
            description: BigQuery table name
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.snowflakeTable.account
          in: query
          description: Snowflake account
          required: true
          schema:
            type: string
            title: account
            description: Snowflake account
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.snowflakeTable.database
          in: query
          description: Snowflake database
          required: true
          schema:
            type: string
            title: database
            description: Snowflake database
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.snowflakeTable.schema
          in: query
          description: Snowflake schema
          required: true
          schema:
            type: string
            title: schema
            description: Snowflake schema
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.snowflakeTable.table
          in: query
          description: Snowflake table
          required: true
          schema:
            type: string
            title: table
            description: Snowflake table
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.redshiftTable.cluster
          in: query
          description: Redshift cluster
          schema:
            type: string
            title: cluster
            description: Redshift cluster
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.redshiftTable.database
          in: query
          description: Redshift database
          required: true
          schema:
            type: string
            title: database
            description: Redshift database
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.redshiftTable.schema
          in: query
          description: Redshift schema
          required: true
          schema:
            type: string
            title: schema
            description: Redshift schema
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.redshiftTable.table
          in: query
          description: Redshift table
          required: true
          schema:
            type: string
            title: table
            description: Redshift table
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.postgresTable.host
          in: query
          description: Postgres hostname without port
          required: true
          schema:
            type: string
            title: host
            description: Postgres hostname without port
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.postgresTable.database
          in: query
          description: Postgres database
          required: true
          schema:
            type: string
            title: database
            description: Postgres database
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.postgresTable.schema
          in: query
          description: Postgres schema
          required: true
          schema:
            type: string
            title: schema
            description: Postgres schema
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.postgresTable.table
          in: query
          description: Postgres table
          required: true
          schema:
            type: string
            title: table
            description: Postgres table
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.mysqlTable.host
          in: query
          description: Mysql hostname without port
          required: true
          schema:
            type: string
            title: host
            description: Mysql hostname without port
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.mysqlTable.schema
          in: query
          description: Mysql database
          required: true
          schema:
            type: string
            title: schema
            description: Mysql database
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.mysqlTable.table
          in: query
          description: Mysql table
          required: true
          schema:
            type: string
            title: table
            description: Mysql table
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.clickhouseTable.host
          in: query
          description: Clickhouse hostname without port
          required: true
          schema:
            type: string
            title: host
            description: Clickhouse hostname without port
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.clickhouseTable.schema
          in: query
          description: Clickhouse database
          required: true
          schema:
            type: string
            title: schema
            description: Clickhouse database
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.clickhouseTable.table
          in: query
          description: Clickhouse table
          required: true
          schema:
            type: string
            title: table
            description: Clickhouse table
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.airflowDag.integrationId
          in: query
          description: Coalesce Quality integration_id that identifies the Airflow instance
          required: true
          schema:
            type: string
            title: integration_id
            description: >-
              Coalesce Quality integration_id that identifies the Airflow
              instance
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.airflowDag.dagId
          in: query
          description: Airflow dag_id that identifies the DAG
          required: true
          schema:
            type: string
            title: dag_id
            description: Airflow dag_id that identifies the DAG
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.airflowTask.integrationId
          in: query
          description: Coalesce Quality integration_id that identifies the Airflow instance
          required: true
          schema:
            type: string
            title: integration_id
            description: >-
              Coalesce Quality integration_id that identifies the Airflow
              instance
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.airflowTask.dagId
          in: query
          description: Airflow dag_id that identifies the DAG
          required: true
          schema:
            type: string
            title: dag_id
            description: Airflow dag_id that identifies the DAG
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.airflowTask.taskId
          in: query
          description: Airflow task_id that identifies the task within the DAG
          required: true
          schema:
            type: string
            title: task_id
            description: Airflow task_id that identifies the task within the DAG
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.custom.id
          in: query
          description: |-
            Id that identifies the custom entity
             The Id should be unique within the custom entity Identifier.
          required: true
          schema:
            type: string
            title: id
            description: |-
              Id that identifies the custom entity
               The Id should be unique within the custom entity Identifier.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.dataproduct.id
          in: query
          description: Dataproduct id that identifies the Dataproduct
          required: true
          schema:
            type: string
            title: id
            format: uuid
            description: Dataproduct id that identifies the Dataproduct
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.synqPath.path
          in: query
          description: >-
            Coalesce Quality path that identifies the Coalesce Quality entity,
            needs to be one of supported paths
          required: true
          schema:
            type: string
            title: path
            description: >-
              Coalesce Quality path that identifies the Coalesce Quality entity,
              needs to be one of supported paths
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.databricksTable.workspace
          in: query
          description: URL of Databricks workspace
          required: true
          schema:
            type: string
            title: workspace
            description: URL of Databricks workspace
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.databricksTable.catalog
          in: query
          description: Databricks catalog
          required: true
          schema:
            type: string
            title: catalog
            description: Databricks catalog
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.databricksTable.schema
          in: query
          description: Databricks schema
          required: true
          schema:
            type: string
            title: schema
            description: Databricks schema
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.databricksTable.table
          in: query
          description: Databricks table or view
          required: true
          schema:
            type: string
            title: table
            description: Databricks table or view
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.trinoTable.host
          in: query
          description: Hostname of the Trino instance
          required: true
          schema:
            type: string
            title: host
            description: Hostname of the Trino instance
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.trinoTable.catalog
          in: query
          description: Trino catalog
          required: true
          schema:
            type: string
            title: catalog
            description: Trino catalog
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.trinoTable.schema
          in: query
          description: Trino schema
          required: true
          schema:
            type: string
            title: schema
            description: Trino schema
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.trinoTable.table
          in: query
          description: Trino table or view
          required: true
          schema:
            type: string
            title: table
            description: Trino table or view
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.sqlMeshModel.integrationId
          in: query
          description: Coalesce Quality integration_id that identifies the dbt Core project
          required: true
          schema:
            type: string
            title: integration_id
            format: uuid
            description: >-
              Coalesce Quality integration_id that identifies the dbt Core
              project
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.sqlMeshModel.fqn
          in: query
          description: SQLMesh model fully qualified name
          required: true
          schema:
            type: string
            title: fqn
            description: SQLMesh model fully qualified name
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.sqlMeshAudit.integrationId
          in: query
          description: Coalesce Quality integration_id that identifies the dbt Core project
          required: true
          schema:
            type: string
            title: integration_id
            format: uuid
            description: >-
              Coalesce Quality integration_id that identifies the dbt Core
              project
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.sqlMeshAudit.fqn
          in: query
          description: SQLMesh model fully qualified name
          required: true
          schema:
            type: string
            title: fqn
            description: SQLMesh model fully qualified name
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.sqlMeshAudit.auditId
          in: query
          description: Identifier of the audit
          required: true
          schema:
            type: string
            title: audit_id
            description: Identifier of the audit
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.mssqlTable.host
          in: query
          description: Hostname of the SQL Server instance
          required: true
          schema:
            type: string
            title: host
            description: Hostname of the SQL Server instance
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.mssqlTable.database
          in: query
          description: SQL Server database
          required: true
          schema:
            type: string
            title: database
            description: SQL Server database
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.mssqlTable.schema
          in: query
          description: SQL Server schema (e.g. "dbo")
          required: true
          schema:
            type: string
            title: schema
            description: SQL Server schema (e.g. "dbo")
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.mssqlTable.table
          in: query
          description: SQL Server table or view
          required: true
          schema:
            type: string
            title: table
            description: SQL Server table or view
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.oracleTable.host
          in: query
          description: Hostname of the Oracle instance
          required: true
          schema:
            type: string
            title: host
            description: Hostname of the Oracle instance
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.oracleTable.serviceName
          in: query
          description: Oracle service name (PDB)
          required: true
          schema:
            type: string
            title: service_name
            description: Oracle service name (PDB)
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.oracleTable.schema
          in: query
          description: Oracle schema (= owning user)
          required: true
          schema:
            type: string
            title: schema
            description: Oracle schema (= owning user)
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.oracleTable.table
          in: query
          description: Oracle table or view
          required: true
          schema:
            type: string
            title: table
            description: Oracle table or view
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.athenaTable.instance
          in: query
          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.
          required: true
          schema:
            type: string
            title: instance
            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.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.athenaTable.catalog
          in: query
          description: |-
            Glue Data Catalog name. Almost always "AwsDataCatalog" — the default
             catalog for Athena unless the customer registered a federated catalog.
          required: true
          schema:
            type: string
            title: catalog
            description: >-
              Glue Data Catalog name. Almost always "AwsDataCatalog" — the
              default
               catalog for Athena unless the customer registered a federated catalog.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.athenaTable.database
          in: query
          description: Glue database (the namespace users typically filter on).
          required: true
          schema:
            type: string
            title: database
            description: Glue database (the namespace users typically filter on).
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.athenaTable.table
          in: query
          description: Glue table or view name.
          required: true
          schema:
            type: string
            title: table
            description: Glue table or view name.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.savedView.id
          in: query
          description: Saved view id (client-supplied UUID) that identifies the saved view
          required: true
          schema:
            type: string
            title: id
            format: uuid
            description: >-
              Saved view id (client-supplied UUID) that identifies the saved
              view
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.fabricTable.instance
          in: query
          description: |-
            Workspace SQL analytics endpoint host, e.g.
             "<workspace-id>.datawarehouse.fabric.microsoft.com".
          required: true
          schema:
            type: string
            title: instance
            description: |-
              Workspace SQL analytics endpoint host, e.g.
               "<workspace-id>.datawarehouse.fabric.microsoft.com".
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.fabricTable.database
          in: query
          description: Fabric warehouse / lakehouse (database).
          required: true
          schema:
            type: string
            title: database
            description: Fabric warehouse / lakehouse (database).
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.fabricTable.schema
          in: query
          description: Schema within the database.
          required: true
          schema:
            type: string
            title: schema
            description: Schema within the database.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.fabricTable.table
          in: query
          description: Table or view name.
          required: true
          schema:
            type: string
            title: table
            description: Table or view name.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.fabricTable.workspaceId
          in: query
          description: |-
            Fabric workspace GUID, decoded from the endpoint host in `instance`.
             Optional and informational: the table is addressed by
             instance/database/schema/table, so leave it empty if you don't have it —
             it does not affect how the identifier resolves.
          schema:
            type: string
            title: workspace_id
            description: >-
              Fabric workspace GUID, decoded from the endpoint host in
              `instance`.
               Optional and informational: the table is addressed by
               instance/database/schema/table, so leave it empty if you don't have it —
               it does not affect how the identifier resolves.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.fabricTable.tenantId
          in: query
          description: >-
            Entra (Azure AD) tenant GUID, decoded from the endpoint host in
            `instance`.
             Optional and informational, like workspace_id.
          schema:
            type: string
            title: tenant_id
            description: >-
              Entra (Azure AD) tenant GUID, decoded from the endpoint host in
              `instance`.
               Optional and informational, like workspace_id.
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.db2Table.host
          in: query
          description: Host name of the Db2 server
          required: true
          schema:
            type: string
            title: host
            description: Host name of the Db2 server
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.db2Table.database
          in: query
          description: Database name or alias, as in `CONNECT TO <database>`
          required: true
          schema:
            type: string
            title: database
            description: Database name or alias, as in `CONNECT TO <database>`
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.db2Table.schema
          in: query
          description: Db2 schema (e.g. "DB2INST1")
          required: true
          schema:
            type: string
            title: schema
            description: Db2 schema (e.g. "DB2INST1")
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitoredId.db2Table.table
          in: query
          description: Db2 table or view
          required: true
          schema:
            type: string
            title: table
            description: Db2 table or view
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.monitorId
          in: query
          description: Identifier of the monitor
          required: true
          schema:
            type: string
            title: monitor_id
            description: Identifier of the monitor
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.segment
          in: query
          description: Optional monitor segmentation identifier
          schema:
            type: string
            title: segment
            description: Optional monitor segmentation identifier
        - name: >-
            deploymentRule.queryConfig.query.parts.identifierList.identifiers.monitor.integrationId
          in: query
          description: Coalesce Quality integration_id of the monitored identifier
          schema:
            type: string
            title: integration_id
            description: Coalesce Quality integration_id of the monitored identifier
            deprecated: true
        - name: deploymentRule.queryConfig.query.parts.withNameSearch.searchQuery
          in: query
          schema:
            type: string
            title: search_query
        - name: deploymentRule.queryConfig.query.parts.withType.type.default
          in: query
          description: Default Coalesce Quality types
          schema:
            $ref: '#/components/schemas/synq.entities.v1.EntityType'
            title: default
            description: Default Coalesce Quality types
        - name: deploymentRule.queryConfig.query.parts.withType.type.custom
          in: query
          description: Custom types as defined through synq.entities.custom.v1.TypesService
          schema:
            type: integer
            title: custom
            format: int32
            description: >-
              Custom types as defined through
              synq.entities.custom.v1.TypesService
        - name: deploymentRule.queryConfig.query.parts.withType.traits
          in: query
          description: |-
            Traits to select by, instead of — or alongside — naming types.

             A trait is a property a type has, so `is_monitorable` means "everything a
             monitor can run on" without listing the forty-odd types that satisfy it
             today. The list it stands for is worked out each time the selection runs,
             so a selection saved this way covers a new platform's tables as soon as we
             support them, and you never have to revisit it.

             Entities carrying any of the traits match. When `types` is also set the two
             narrow each other: the entity must be one of the named types AND carry one
             of the traits.

             Accepted values, and what each one means, come from the selection-query
             grammar the API publishes (`describe_resolver_ql`, or the query editor's
             reference). A name that is not in it selects nothing rather than being
             ignored, so a typo narrows the result to empty instead of widening it —
             check a trait against the grammar before storing a selection. In a query
             written as text this is `with_type(traits="is_monitorable")`, and there a
             name outside the grammar is rejected outright.

             A trait may also be a type alias, spelled `alias:<name>` where `<name>` is
             one of the aliases the grammar lists among the entity types, e.g.
             `alias:table`. It selects every type the alias stands for, worked out each
             time the selection runs like any other trait. A selection written as
             `with_type("table")` is stored this way and reads back with
             `traits: ["alias:table"]`; writing that back keeps the same selection. In a
             query written as text an alias is always `with_type("table")`, never
             `traits="alias:table"`.
          schema:
            type: array
            items:
              type: string
            title: traits
            description: |-
              Traits to select by, instead of — or alongside — naming types.

               A trait is a property a type has, so `is_monitorable` means "everything a
               monitor can run on" without listing the forty-odd types that satisfy it
               today. The list it stands for is worked out each time the selection runs,
               so a selection saved this way covers a new platform's tables as soon as we
               support them, and you never have to revisit it.

               Entities carrying any of the traits match. When `types` is also set the two
               narrow each other: the entity must be one of the named types AND carry one
               of the traits.

               Accepted values, and what each one means, come from the selection-query
               grammar the API publishes (`describe_resolver_ql`, or the query editor's
               reference). A name that is not in it selects nothing rather than being
               ignored, so a typo narrows the result to empty instead of widening it —
               check a trait against the grammar before storing a selection. In a query
               written as text this is `with_type(traits="is_monitorable")`, and there a
               name outside the grammar is rejected outright.

               A trait may also be a type alias, spelled `alias:<name>` where `<name>` is
               one of the aliases the grammar lists among the entity types, e.g.
               `alias:table`. It selects every type the alias stands for, worked out each
               time the selection runs like any other trait. A selection written as
               `with_type("table")` is stored this way and reads back with
               `traits: ["alias:table"]`; writing that back keeps the same selection. In a
               query written as text an alias is always `with_type("table")`, never
               `traits="alias:table"`.
        - name: deploymentRule.queryConfig.query.parts.withAnnotation.name
          in: query
          schema:
            type: string
            title: name
        - name: deploymentRule.queryConfig.query.parts.withAnnotation.acceptedValue
          in: query
          schema:
            type: string
            title: accepted_value
            deprecated: true
        - name: deploymentRule.queryConfig.query.parts.withAnnotation.acceptedValues
          in: query
          schema:
            type: array
            items:
              type: string
            title: accepted_values
        - name: deploymentRule.queryConfig.query.parts.inFolder.path
          in: query
          description: >-
            Opaque folder identifiers (a folder's own entity id). `folders` is
            the
             structured, human-authorable alternative. When `path` is the only source
             set and `deep` is unset, `deep` defaults to true for back-compat with
             queries authored before `deep` existed.
          schema:
            type: array
            items:
              type: string
            title: path
            description: >-
              Opaque folder identifiers (a folder's own entity id). `folders` is
              the
               structured, human-authorable alternative. When `path` is the only source
               set and `deep` is unset, `deep` defaults to true for back-compat with
               queries authored before `deep` existed.
        - name: deploymentRule.queryConfig.query.parts.inFolder.folders.rootEntityId
          in: query
          description: >-
            Opaque id of the entity the folder hierarchy hangs under — an
            integration
             root or container (for example a warehouse instance, a database, or a
             transformation project). Take it verbatim from `FolderRef.root_entity_id`
             of a folder you already read, or from an entity id returned elsewhere.
          schema:
            type: string
            title: root_entity_id
            description: >-
              Opaque id of the entity the folder hierarchy hangs under — an
              integration
               root or container (for example a warehouse instance, a database, or a
               transformation project). Take it verbatim from `FolderRef.root_entity_id`
               of a folder you already read, or from an entity id returned elsewhere.
        - name: deploymentRule.queryConfig.query.parts.inFolder.folders.folders
          in: query
          description: >-
            Ordered folder names from the root down to this folder (root first,
            leaf
             last), for example ["staging", "sales"]. Empty means the ref points at the
             root entity itself. Folder names are kept as separate segments (not joined
             with "/") because some platforms allow "/" inside a single folder name.
          schema:
            type: array
            items:
              type: string
            title: folders
            description: >-
              Ordered folder names from the root down to this folder (root
              first, leaf
               last), for example ["staging", "sales"]. Empty means the ref points at the
               root entity itself. Folder names are kept as separate segments (not joined
               with "/") because some platforms allow "/" inside a single folder name.
        - name: deploymentRule.queryConfig.query.parts.inFolder.folderOf.entityIds
          in: query
          description: >-
            Simplified source: the assets named directly by opaque entity id.
            Use this
             for the common "same folder as these specific assets" case; equivalent to an
             input_query that lists the same ids.
          schema:
            type: array
            items:
              type: string
            title: entity_ids
            description: >-
              Simplified source: the assets named directly by opaque entity id.
              Use this
               for the common "same folder as these specific assets" case; equivalent to an
               input_query that lists the same ids.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.bigquery.project
          in: query
          description: BigQuery project
          required: true
          schema:
            type: string
            title: project
            description: BigQuery project
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.clickhouse.host
          in: query
          description: Clickhouse host inclusive of port
          required: true
          schema:
            type: string
            title: host
            description: Clickhouse host inclusive of port
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.clickhouse.schema
          in: query
          description: Clickhouse database
          required: true
          schema:
            type: string
            title: schema
            description: Clickhouse database
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.snowflake.account
          in: query
          description: Snowflake account
          required: true
          schema:
            type: string
            title: account
            description: Snowflake account
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.snowflake.database
          in: query
          description: Snowflake database
          required: true
          schema:
            type: string
            title: database
            description: Snowflake database
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.redshift.cluster
          in: query
          description: Redshift cluster
          required: true
          schema:
            type: string
            title: cluster
            description: Redshift cluster
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.redshift.database
          in: query
          description: Redshift database
          required: true
          schema:
            type: string
            title: database
            description: Redshift database
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.postgres.host
          in: query
          description: Postgres host inclusive of port
          required: true
          schema:
            type: string
            title: host
            description: Postgres host inclusive of port
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.postgres.database
          in: query
          description: Postgres database
          required: true
          schema:
            type: string
            title: database
            description: Postgres database
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.mysql.host
          in: query
          description: Mysql host inclusive of port
          required: true
          schema:
            type: string
            title: host
            description: Mysql host inclusive of port
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.databricks.workspace
          in: query
          description: URL of the databricks workspace
          required: true
          schema:
            type: string
            title: workspace
            description: URL of the databricks workspace
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.dbtCloud.apiEndpoint
          in: query
          description: API endpoint for Dbt Cloud
          required: true
          schema:
            type: string
            title: api_endpoint
            description: API endpoint for Dbt Cloud
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.dbtCloud.accountId
          in: query
          description: Account ID
          required: true
          schema:
            type: string
            title: account_id
            description: Account ID
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.dbtCloud.projectId
          in: query
          description: Project ID
          required: true
          schema:
            type: string
            title: project_id
            description: Project ID
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.sqlMesh.defaultDatabaseInstance
          in: query
          description: Default database instance for SQL Mesh
          required: true
          schema:
            type: string
            title: default_database_instance
            description: Default database instance for SQL Mesh
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.duckdb.motherduckAccount
          in: query
          schema:
            type: string
            title: motherduck_account
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.trino.coordinator
          in: query
          schema:
            type: string
            title: coordinator
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.mssql.host
          in: query
          description: SQL Server host
          required: true
          schema:
            type: string
            title: host
            description: SQL Server host
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.mssql.database
          in: query
          description: Database name
          required: true
          schema:
            type: string
            title: database
            description: Database name
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.oracle.host
          in: query
          description: Oracle host
          required: true
          schema:
            type: string
            title: host
            description: Oracle host
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.oracle.serviceName
          in: query
          description: Oracle service name (PDB)
          required: true
          schema:
            type: string
            title: service_name
            description: Oracle service name (PDB)
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.athena.instance
          in: query
          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.
          required: true
          schema:
            type: string
            title: instance
            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.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.athena.catalog
          in: query
          description: |-
            Glue Data Catalog name. Almost always "AwsDataCatalog" — the default
             catalog for Athena unless the customer registered a federated catalog.
          required: true
          schema:
            type: string
            title: catalog
            description: >-
              Glue Data Catalog name. Almost always "AwsDataCatalog" — the
              default
               catalog for Athena unless the customer registered a federated catalog.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.fabric.instance
          in: query
          description: |-
            Workspace SQL analytics endpoint host, e.g.
             "<workspace-id>.datawarehouse.fabric.microsoft.com". Identifies the Fabric
             workspace the integration connects to. Fabric is workspace-scoped with
             cross-database queries, so the workspace host alone identifies the platform
             (like Databricks' workspace URL); a specific warehouse/table is addressed by
             FabricTableIdentifier.
          required: true
          schema:
            type: string
            title: instance
            description: |-
              Workspace SQL analytics endpoint host, e.g.
               "<workspace-id>.datawarehouse.fabric.microsoft.com". Identifies the Fabric
               workspace the integration connects to. Fabric is workspace-scoped with
               cross-database queries, so the workspace host alone identifies the platform
               (like Databricks' workspace URL); a specific warehouse/table is addressed by
               FabricTableIdentifier.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.fabric.workspaceId
          in: query
          description: >-
            Fabric workspace GUID — the identifier used by the Fabric REST API
            for
             workspace-scoped resources. The Fabric endpoint host in `instance` encodes
             the tenant and workspace GUIDs; this is the decoded workspace GUID, provided
             so you don't have to decode it yourself. `instance` remains the identifying
             value. Optional: empty when the host isn't a standard Fabric endpoint.
          schema:
            type: string
            title: workspace_id
            description: >-
              Fabric workspace GUID — the identifier used by the Fabric REST API
              for
               workspace-scoped resources. The Fabric endpoint host in `instance` encodes
               the tenant and workspace GUIDs; this is the decoded workspace GUID, provided
               so you don't have to decode it yourself. `instance` remains the identifying
               value. Optional: empty when the host isn't a standard Fabric endpoint.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.fabric.tenantId
          in: query
          description: >-
            Entra (Azure AD) tenant GUID, decoded from the endpoint host in
            `instance`
             alongside workspace_id. Optional: empty when the host isn't a standard
             Fabric endpoint.
          schema:
            type: string
            title: tenant_id
            description: >-
              Entra (Azure AD) tenant GUID, decoded from the endpoint host in
              `instance`
               alongside workspace_id. Optional: empty when the host isn't a standard
               Fabric endpoint.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.db2.host
          in: query
          description: Host name of the Db2 server
          required: true
          schema:
            type: string
            title: host
            description: Host name of the Db2 server
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.db2.database
          in: query
          description: Database name or alias, as in `CONNECT TO <database>`
          required: true
          schema:
            type: string
            title: database
            description: Database name or alias, as in `CONNECT TO <database>`
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDataPlatform.identifier.synqIntegrationId
          in: query
          description: >-
            Coalesce Quality integration ID maps to the created integration on
            the Coalesce Quality platform.
          schema:
            type: string
            title: synq_integration_id
            description: >-
              Coalesce Quality integration ID maps to the created integration on
              the Coalesce Quality platform.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.withDataPlatformType.types
          in: query
          schema:
            type: array
            items:
              $ref: '#/components/schemas/synq.platforms.v1.DataPlatformType'
            title: types
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inFolder.deep
          in: query
          description: >-
            When false or unset, matches only the direct members of the
            folder(s). When
             true, matches the entire recursive subtree (members of subfolders too).

             Exception: when only the legacy `path` source is set and `deep` is unset,
             it defaults to true (preserves the behaviour of queries authored before this
             flag existed). With `folders` or `folder_of`, unset means false (shallow).
          schema:
            type: boolean
            title: deep
            description: >-
              When false or unset, matches only the direct members of the
              folder(s). When
               true, matches the entire recursive subtree (members of subfolders too).

               Exception: when only the legacy `path` source is set and `deep` is unset,
               it defaults to true (preserves the behaviour of queries authored before this
               flag existed). With `folders` or `folder_of`, unset means false (shallow).
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.inDomain.domainId
          in: query
          schema:
            type: string
            title: domain_id
            format: uuid
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.identitiesOf.inputQuery.operand
          in: query
          description: Defaults to AND if not specified.
          schema:
            $ref: '#/components/schemas/synq.queries.v1.QueryOperand'
            title: operand
            description: Defaults to AND if not specified.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.entityIds.entityIds
          in: query
          description: |-
            The entities to select. An id may not be blank.

             An empty list selects no entities, exactly as an empty `identifier_list`
             does. Be deliberate about it, because it is not the same as leaving the part
             out: a part that selects nothing still counts, so it empties an AND, adds
             nothing to an OR, and removes nothing from an EXCEPT. If what you mean is
             "do not restrict on specific entities", omit the part instead of sending it
             empty.

             Ids may be up to 1024 characters — the same limit as `Identifier.entity_id`,
             where you read them from, so any id the API returned is accepted here.
          schema:
            type: array
            items:
              type: string
              maxLength: 1024
              minLength: 1
            title: entity_ids
            description: |-
              The entities to select. An id may not be blank.

               An empty list selects no entities, exactly as an empty `identifier_list`
               does. Be deliberate about it, because it is not the same as leaving the part
               out: a part that selects nothing still counts, so it empties an AND, adds
               nothing to an OR, and removes nothing from an EXCEPT. If what you mean is
               "do not restrict on specific entities", omit the part instead of sending it
               empty.

               Ids may be up to 1024 characters — the same limit as `Identifier.entity_id`,
               where you read them from, so any id the API returned is accepted here.
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.inputQuery.parts.unsupported.queryJson
          in: query
          schema:
            type: string
            title: query_json
        - name: >-
            deploymentRule.queryConfig.query.parts.inFolder.folderOf.includeAllAncestors
          in: query
          description: >-
            When false (default): only each asset's immediate parent folder.
            When true:
             every ancestor folder up the hierarchy, so `InFolder` then also matches
             assets in those ancestor folders.
          schema:
            type: boolean
            title: include_all_ancestors
            description: >-
              When false (default): only each asset's immediate parent folder.
              When true:
               every ancestor folder up the hierarchy, so `InFolder` then also matches
               assets in those ancestor folders.
        - name: deploymentRule.queryConfig.query.parts.query.operand
          in: query
          schema:
            $ref: '#/components/schemas/synq.queries.v1.QueryOperand'
            title: operand
        - name: deploymentRule.queryConfig.resolverQl
          in: query
          description: >-
            ResolverQL selection string — an advanced, more expressive
            alternative to
             `query`. ResolverQL is a superset of the structured `query`: use it for
             selections `query` cannot express (e.g. lineage walks, column predicates).
             When set (non-empty) on write, `resolver_ql` is the source of truth and the
             structured `query` is ignored. The selection is compiled when it is written
             and stored in that form, so the text itself is not kept: two spellings of the
             same selection store the same rule, and a type alias such as "table" is
             expanded to the types it names at the time of the write. On read this field
             carries the canonical rendering of the stored selection, equal to
             `rendered_resolver_ql`, whichever way the rule was written, and is empty when
             the selection has no ResolverQL representation. Writing a read response back
             unchanged stores the same selection. `query` is always populated.
          schema:
            type: string
            title: resolver_ql
            description: >-
              ResolverQL selection string — an advanced, more expressive
              alternative to
               `query`. ResolverQL is a superset of the structured `query`: use it for
               selections `query` cannot express (e.g. lineage walks, column predicates).
               When set (non-empty) on write, `resolver_ql` is the source of truth and the
               structured `query` is ignored. The selection is compiled when it is written
               and stored in that form, so the text itself is not kept: two spellings of the
               same selection store the same rule, and a type alias such as "table" is
               expanded to the types it names at the time of the write. On read this field
               carries the canonical rendering of the stored selection, equal to
               `rendered_resolver_ql`, whichever way the rule was written, and is empty when
               the selection has no ResolverQL representation. Writing a read response back
               unchanged stores the same selection. `query` is always populated.
        - name: deploymentRule.queryConfig.renderedResolverQl
          in: query
          description: >-
            Canonical ResolverQL rendering of this rule's selection, populated
            for every
             rule regardless of how it was authored. OUTPUT ONLY — it is ignored on
             write; set `resolver_ql` to author a selection in ResolverQL. Compare
             selections by this field rather than by the text a rule was written with,
             which may be spelled differently.
          schema:
            type: string
            title: rendered_resolver_ql
            description: >-
              Canonical ResolverQL rendering of this rule's selection, populated
              for every
               rule regardless of how it was authored. OUTPUT ONLY — it is ignored on
               write; set `resolver_ql` to author a selection in ResolverQL. Compare
               selections by this field rather than by the text a rule was written with,
               which may be spelled differently.
        - name: deploymentRule.queryConfig.tests.name
          in: query
          description: >-
            Human friendly name for this test. Required (non-empty) for
            business_rule_test
             and business_query_test — for those two kinds, name is the test's identity key
             across rule redeployments, so a renamed test is treated as a different test.
             Optional for every other kind: leave it unset and a name is generated.
          schema:
            type: string
            title: name
            description: >-
              Human friendly name for this test. Required (non-empty) for
              business_rule_test
               and business_query_test — for those two kinds, name is the test's identity key
               across rule redeployments, so a renamed test is treated as a different test.
               Optional for every other kind: leave it unset and a name is generated.
        - name: deploymentRule.queryConfig.tests.description
          in: query
          description: >-
            Description of purpose and motivation, copied onto every test this
            rule deploys.
          schema:
            type: string
            title: description
            description: >-
              Description of purpose and motivation, copied onto every test this
              rule deploys.
        - name: deploymentRule.queryConfig.tests.severity
          in: query
          description: >-
            Overrides the rule's config-level severity for this test only. Leave
            unset to
             use the config-level severity.
          schema:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Severity'
            title: severity
            description: >-
              Overrides the rule's config-level severity for this test only.
              Leave unset to
               use the config-level severity.
        - name: deploymentRule.queryConfig.tests.notNullTest.columnNames
          in: query
          description: List of column names to check for NULL values
          schema:
            type: array
            items:
              type: string
              minItems: 1
              uniqueItems: true
            title: column_names
            minItems: 1
            uniqueItems: true
            description: List of column names to check for NULL values
        - name: deploymentRule.queryConfig.tests.notNullTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.emptyTest.columnNames
          in: query
          description: List of column names to check for empty values
          schema:
            type: array
            items:
              type: string
              minItems: 1
              uniqueItems: true
            title: column_names
            minItems: 1
            uniqueItems: true
            description: List of column names to check for empty values
        - name: deploymentRule.queryConfig.tests.emptyTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.acceptedValuesTest.columnName
          in: query
          description: Name of the column to validate
          required: true
          schema:
            type: string
            title: column_name
            description: Name of the column to validate
        - name: >-
            deploymentRule.queryConfig.tests.acceptedValuesTest.acceptedValues.stringLiteral
          in: query
          description: >-
            Literal value that should be quoted in SQL (e.g., '2025-05-12',
            'active')
          schema:
            type: string
            title: string_literal
            description: >-
              Literal value that should be quoted in SQL (e.g., '2025-05-12',
              'active')
        - name: >-
            deploymentRule.queryConfig.tests.acceptedValuesTest.acceptedValues.expression
          in: query
          description: >-
            SQL expression, numbers to be used as plain text (e.g., NOW(),
            COUNT(*), true, 1.1)
          schema:
            type: string
            title: expression
            description: >-
              SQL expression, numbers to be used as plain text (e.g., NOW(),
              COUNT(*), true, 1.1)
        - name: deploymentRule.queryConfig.tests.acceptedValuesTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.rejectedValuesTest.columnName
          in: query
          description: Name of the column to validate
          required: true
          schema:
            type: string
            title: column_name
            description: Name of the column to validate
        - name: deploymentRule.queryConfig.tests.rejectedValuesTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.uniqueTest.columnNames
          in: query
          description: List of columns that should form a unique combination
          schema:
            type: array
            items:
              type: string
              minItems: 1
              uniqueItems: true
            title: column_names
            minItems: 1
            uniqueItems: true
            description: List of columns that should form a unique combination
        - name: deploymentRule.queryConfig.tests.uniqueTest.timePartitionColumnName
          in: query
          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
          schema:
            type: string
            title: time_partition_column_name
            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
        - name: deploymentRule.queryConfig.tests.uniqueTest.timeWindowSeconds
          in: query
          description: Time window for uniqueness check (in seconds)
          schema:
            type:
              - integer
              - string
            title: time_window_seconds
            format: int64
            description: Time window for uniqueness check (in seconds)
        - name: >-
            deploymentRule.queryConfig.tests.freshnessTest.timePartitionColumnName
          in: query
          description: Name of the timestamp column used for freshness check
          required: true
          schema:
            type: string
            title: time_partition_column_name
            description: Name of the timestamp column used for freshness check
        - name: deploymentRule.queryConfig.tests.freshnessTest.timeWindowSeconds
          in: query
          description: Time window for freshness check (in seconds)
          schema:
            type:
              - integer
              - string
            title: time_window_seconds
            format: int64
            description: Time window for freshness check (in seconds)
        - name: deploymentRule.queryConfig.tests.freshnessTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.minMaxTest.columnName
          in: query
          description: Name of the numeric column to validate
          required: true
          schema:
            type: string
            title: column_name
            description: Name of the numeric column to validate
        - name: deploymentRule.queryConfig.tests.minMaxTest.strictly
          in: query
          description: If true, bounds are exclusive
          schema:
            type: boolean
            title: strictly
            description: If true, bounds are exclusive
        - name: deploymentRule.queryConfig.tests.minMaxTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.relativeTimeTest.columnName
          in: query
          description: Name of the first time column to compare
          required: true
          schema:
            type: string
            title: column_name
            description: Name of the first time column to compare
        - name: deploymentRule.queryConfig.tests.relativeTimeTest.relativeColumnName
          in: query
          description: Name of the second time column that should be later than the first
          required: true
          schema:
            type: string
            title: relative_column_name
            description: Name of the second time column that should be later than the first
        - name: deploymentRule.queryConfig.tests.relativeTimeTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.businessRuleTest.sqlExpression
          in: query
          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.

             Placeholder: `{{ table }}` is substituted with the anchor table's fully
             qualified name, quoted for the warehouse — the matched table when the test
             is deployed by a deployment rule. It is the only supported placeholder;
             any other `{{ name }}` token is rejected. It renders a table name, so it
             belongs where a table name goes — the FROM clause of a subquery of your own:
             "total > (SELECT max(total) FROM {{ table }})".

             It is not a column qualifier. The generated FROM clause carries no alias, and
             on BigQuery the fully qualified name is a single quoted identifier, so
             "{{ table }}.id" does not resolve. To name the anchor's columns, use
             BusinessQueryTest, where you write the FROM clause and can alias it.
          required: true
          schema:
            type: string
            title: sql_expression
            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.

               Placeholder: `{{ table }}` is substituted with the anchor table's fully
               qualified name, quoted for the warehouse — the matched table when the test
               is deployed by a deployment rule. It is the only supported placeholder;
               any other `{{ name }}` token is rejected. It renders a table name, so it
               belongs where a table name goes — the FROM clause of a subquery of your own:
               "total > (SELECT max(total) FROM {{ table }})".

               It is not a column qualifier. The generated FROM clause carries no alias, and
               on BigQuery the fully qualified name is a single quoted identifier, so
               "{{ table }}.id" does not resolve. To name the anchor's columns, use
               BusinessQueryTest, where you write the FROM clause and can alias it.
        - name: deploymentRule.queryConfig.tests.businessRuleTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.minValueTest.columnName
          in: query
          description: Name of the numeric column to validate
          required: true
          schema:
            type: string
            title: column_name
            description: Name of the numeric column to validate
        - name: deploymentRule.queryConfig.tests.minValueTest.strictly
          in: query
          description: If true, the minimum value is exclusive
          schema:
            type: boolean
            title: strictly
            description: If true, the minimum value is exclusive
        - name: deploymentRule.queryConfig.tests.minValueTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.maxValueTest.columnName
          in: query
          description: Name of the numeric column to validate
          required: true
          schema:
            type: string
            title: column_name
            description: Name of the numeric column to validate
        - name: deploymentRule.queryConfig.tests.maxValueTest.strictly
          in: query
          description: If true, the maximum value is exclusive
          schema:
            type: boolean
            title: strictly
            description: If true, the maximum value is exclusive
        - name: deploymentRule.queryConfig.tests.maxValueTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: >-
            deploymentRule.queryConfig.tests.relationshipsTest.references.columns.source
          in: query
          description: Column name in the source table
          required: true
          schema:
            type: string
            title: source
            description: Column name in the source table
        - name: >-
            deploymentRule.queryConfig.tests.relationshipsTest.references.columns.reference
          in: query
          description: Column name in the reference table
          required: true
          schema:
            type: string
            title: reference
            description: Column name in the reference table
        - name: deploymentRule.queryConfig.tests.relationshipsTest.ignoreNulls
          in: query
          description: >-
            If true, source rows where all join columns are NULL are excluded
            from results
          schema:
            type: boolean
            title: ignore_nulls
            description: >-
              If true, source rows where all join columns are NULL are excluded
              from results
        - name: >-
            deploymentRule.queryConfig.tests.relationshipsTest.timePartitionColumn
          in: query
          description: Column name used to filter source rows by time (e.g., "created_at")
          schema:
            type: string
            title: time_partition_column
            description: >-
              Column name used to filter source rows by time (e.g.,
              "created_at")
        - name: deploymentRule.queryConfig.tests.relationshipsTest.timeWindowSeconds
          in: query
          description: Time window in seconds - only check source rows within this window
          schema:
            type:
              - integer
              - string
            title: time_window_seconds
            format: int64
            description: Time window in seconds - only check source rows within this window
        - name: deploymentRule.queryConfig.tests.relationshipsTest.selectColumns
          in: query
          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.
          schema:
            type: array
            items:
              type: string
              uniqueItems: true
            title: select_columns
            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.
        - name: deploymentRule.queryConfig.tests.businessQueryTest.sqlQuery
          in: query
          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.

             Placeholder: `{{ table }}` is substituted with the anchor table's fully
             qualified name, quoted for the warehouse — the matched table when the test
             is deployed by a deployment rule, which is how one query covers every table
             the rule matches instead of being copied onto each of them. It is the only
             supported placeholder; any other `{{ name }}` token is rejected.

             Note: this test does not expose a `select_columns` option. The author
             controls the SELECT shape directly in `sql_query`.
          required: true
          schema:
            type: string
            title: sql_query
            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.

               Placeholder: `{{ table }}` is substituted with the anchor table's fully
               qualified name, quoted for the warehouse — the matched table when the test
               is deployed by a deployment rule, which is how one query covers every table
               the rule matches instead of being copied onto each of them. It is the only
               supported placeholder; any other `{{ name }}` token is rejected.

               Note: this test does not expose a `select_columns` option. The author
               controls the SELECT shape directly in `sql_query`.
        - name: deploymentRule.queryConfig.recurrenceRule
          in: query
          description: >-
            [Recurrence
            rule](https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html)
             for the execution schedule applied to every test this rule deploys. Empty
             means on-demand — deployed tests are never scheduled to run automatically.
             When set, it must carry an inline `DTSTART:` naming the first occurrence, e.g.
             "DTSTART:20260101T000000Z\nRRULE:FREQ=DAILY".
          schema:
            type: string
            title: recurrence_rule
            description: >-
              [Recurrence
              rule](https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html)
               for the execution schedule applied to every test this rule deploys. Empty
               means on-demand — deployed tests are never scheduled to run automatically.
               When set, it must carry an inline `DTSTART:` naming the first occurrence, e.g.
               "DTSTART:20260101T000000Z\nRRULE:FREQ=DAILY".
        - name: deploymentRule.queryConfig.timezone
          in: query
          description: >-
            IANA timezone name (e.g., "Europe/Prague", "America/New_York") used
            to
             interpret recurrence_rule. Empty defaults to UTC.
          schema:
            type: string
            title: timezone
            description: >-
              IANA timezone name (e.g., "Europe/Prague", "America/New_York")
              used to
               interpret recurrence_rule. Empty defaults to UTC.
        - name: deploymentRule.queryConfig.severity
          in: query
          description: |-
            Severity applied to every test this rule deploys, unless a RuleTest
             overrides it. Required — must be set to a value other than unspecified.
          schema:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Severity'
            not:
              enum:
                - 0
            title: severity
            description: >-
              Severity applied to every test this rule deploys, unless a
              RuleTest
               overrides it. Required — must be set to a value other than unspecified.
        - name: deploymentRule.queryConfig.saveFailures
          in: query
          description: >-
            Applied to every test this rule deploys. Toggles saving of failure
            runs.
          schema:
            type: boolean
            title: save_failures
            description: >-
              Applied to every test this rule deploys. Toggles saving of failure
              runs.
        - name: deploymentRule.queryConfig.keepRemovedTests
          in: query
          description: |-
            When a previously matched table or view stops matching this rule's
             selection, its deployed tests are deleted by default. Set true to keep
             them as-is instead — they remain rule-managed but are no longer resynced.
          schema:
            type: boolean
            title: keep_removed_tests
            description: |-
              When a previously matched table or view stops matching this rule's
               selection, its deployed tests are deleted by default. Set true to keep
               them as-is instead — they remain rule-managed but are no longer resynced.
        - name: deploymentRule.exclusiveQueryConfig.resolverQl
          in: query
          description: |-
            ResolverQL selection string for the exclusion set. Same semantics as
             SqlTestsQueryConfig.resolver_ql: when set on write it takes precedence over
             `query` and is stored compiled; on read it carries the canonical rendering
             of the stored selection, equal to `rendered_resolver_ql`. `query` is always
             populated.
          schema:
            type: string
            title: resolver_ql
            description: >-
              ResolverQL selection string for the exclusion set. Same semantics
              as
               SqlTestsQueryConfig.resolver_ql: when set on write it takes precedence over
               `query` and is stored compiled; on read it carries the canonical rendering
               of the stored selection, equal to `rendered_resolver_ql`. `query` is always
               populated.
        - name: deploymentRule.exclusiveQueryConfig.renderedResolverQl
          in: query
          description: >-
            Canonical ResolverQL rendering of the exclusion selection. OUTPUT
            ONLY,
             populated for every rule, ignored on write.
          schema:
            type: string
            title: rendered_resolver_ql
            description: >-
              Canonical ResolverQL rendering of the exclusion selection. OUTPUT
              ONLY,
               populated for every rule, ignored on write.
        - name: deploymentRule.staticConfig.path
          in: query
          description: Synq path of the table or view this rule deploys tests onto.
          schema:
            type: string
            title: path
            minLength: 1
            description: Synq path of the table or view this rule deploys tests onto.
        - name: deploymentRule.staticConfig.recurrenceRule
          in: query
          description: >-
            [Recurrence
            rule](https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html)
             for the execution schedule applied to every test this rule deploys. Empty
             means on-demand. When set, it must carry an inline `DTSTART:` naming the first
             occurrence, e.g. "DTSTART:20260101T000000Z\nRRULE:FREQ=DAILY".
          schema:
            type: string
            title: recurrence_rule
            description: >-
              [Recurrence
              rule](https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html)
               for the execution schedule applied to every test this rule deploys. Empty
               means on-demand. When set, it must carry an inline `DTSTART:` naming the first
               occurrence, e.g. "DTSTART:20260101T000000Z\nRRULE:FREQ=DAILY".
        - name: deploymentRule.staticConfig.timezone
          in: query
          description: >-
            IANA timezone name used to interpret recurrence_rule. Empty defaults
            to UTC.
          schema:
            type: string
            title: timezone
            description: >-
              IANA timezone name used to interpret recurrence_rule. Empty
              defaults to UTC.
        - name: deploymentRule.staticConfig.severity
          in: query
          description: |-
            Severity applied to every test this rule deploys, unless a RuleTest
             overrides it. Required — must be set to a value other than unspecified.
          schema:
            $ref: '#/components/schemas/synq.datachecks.sqltests.v1.Severity'
            not:
              enum:
                - 0
            title: severity
            description: >-
              Severity applied to every test this rule deploys, unless a
              RuleTest
               overrides it. Required — must be set to a value other than unspecified.
        - name: deploymentRule.staticConfig.saveFailures
          in: query
          description: >-
            Applied to every test this rule deploys. Toggles saving of failure
            runs.
          schema:
            type: boolean
            title: save_failures
            description: >-
              Applied to every test this rule deploys. Toggles saving of failure
              runs.
        - name: deploymentRule.exclusiveStaticConfig.path
          in: query
          description: Synq path of the table or view this rule exclusively owns.
          schema:
            type: string
            title: path
            minLength: 1
            description: Synq path of the table or view this rule exclusively owns.
        - name: deploymentRule.source
          in: query
          schema:
            $ref: '#/components/schemas/synq.v1.Source'
            title: source
        - name: deploymentRule.configId
          in: query
          description: >-
            Config ID this rule was authored from, when deployed via
            configuration as
             code. Unset for rules authored directly through this API.

             On a write this field is only ever set, never unset: omitting it keeps the
             stored value, so a full-replace update cannot detach the rule from the
             config that owns it. An empty string is a real config id — the one a deploy
             that declares no namespace uses — so sending it attaches the rule to that
             config rather than clearing the field. No value detaches a rule; recreating
             it is the only way to hand it back to the app.
          schema:
            type: string
            title: config_id
            description: >-
              Config ID this rule was authored from, when deployed via
              configuration as
               code. Unset for rules authored directly through this API.

               On a write this field is only ever set, never unset: omitting it keeps the
               stored value, so a full-replace update cannot detach the rule from the
               config that owns it. An empty string is a real config id — the one a deploy
               that declares no namespace uses — so sending it attaches the rule to that
               config rather than clearing the field. No value detaches a rule; recreating
               it is the only way to hand it back to the app.
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/synq.datachecks.sqltests.v1.GetSqlTestDeployOverviewResponse
components:
  schemas:
    synq.entities.v1.EntityType:
      type: string
      title: EntityType
      enum:
        - ENTITY_TYPE_UNSPECIFIED
        - ENTITY_TYPE_BQ_TABLE
        - ENTITY_TYPE_BQ_VIEW
        - ENTITY_TYPE_LOOKER_LOOK
        - ENTITY_TYPE_LOOKER_EXPLORE
        - ENTITY_TYPE_LOOKER_VIEW
        - ENTITY_TYPE_LOOKER_DASHBOARD
        - ENTITY_TYPE_LOOKER_INSTANCE
        - ENTITY_TYPE_DBT_MODEL
        - ENTITY_TYPE_DBT_TEST
        - ENTITY_TYPE_DBT_SOURCE
        - ENTITY_TYPE_DBT_PROJECT
        - ENTITY_TYPE_DBT_METRIC
        - ENTITY_TYPE_DBT_SNAPSHOT
        - ENTITY_TYPE_DBT_SEED
        - ENTITY_TYPE_DBT_ANALYSIS
        - ENTITY_TYPE_DBT_EXPOSURE
        - ENTITY_TYPE_DBT_GROUP
        - ENTITY_TYPE_DBT_SEMANTIC_MODEL
        - ENTITY_TYPE_DBT_CLOUD_PROJECT
        - ENTITY_TYPE_DBT_CLOUD_JOB
        - ENTITY_TYPE_SNOWFLAKE_TABLE
        - ENTITY_TYPE_SNOWFLAKE_VIEW
        - ENTITY_TYPE_SNOWFLAKE_STREAM
        - ENTITY_TYPE_SNOWFLAKE_DYNAMIC_TABLE
        - ENTITY_TYPE_SNOWFLAKE_TASK
        - ENTITY_TYPE_SNOWFLAKE_EXTERNAL_TABLE
        - ENTITY_TYPE_SNOWFLAKE_MATERIALIZED_VIEW
        - ENTITY_TYPE_SNOWFLAKE_PROCEDURE
        - ENTITY_TYPE_SNOWFLAKE_FUNCTION
        - ENTITY_TYPE_SNOWFLAKE_SEMANTIC_VIEW
        - ENTITY_TYPE_SNOWFLAKE_STAGE
        - ENTITY_TYPE_SNOWFLAKE_STREAMLIT
        - ENTITY_TYPE_SNOWFLAKE_NOTEBOOK
        - ENTITY_TYPE_SNOWFLAKE_WAREHOUSE
        - ENTITY_TYPE_SNOWFLAKE_PIPE
        - ENTITY_TYPE_SNOWFLAKE_CORTEX_SEARCH_SERVICE
        - ENTITY_TYPE_REDSHIFT_TABLE
        - ENTITY_TYPE_REDSHIFT_VIEW
        - ENTITY_TYPE_REDSHIFT_PROCEDURE
        - ENTITY_TYPE_REDSHIFT_FUNCTION
        - ENTITY_TYPE_TABLEAU_EMBEDDED
        - ENTITY_TYPE_TABLEAU_PUBLISHED
        - ENTITY_TYPE_TABLEAU_CUSTOM_SQL
        - ENTITY_TYPE_TABLEAU_TABLE
        - ENTITY_TYPE_TABLEAU_SHEET
        - ENTITY_TYPE_TABLEAU_DASHBOARD
        - ENTITY_TYPE_TABLEAU_WORKBOOK
        - ENTITY_TYPE_TABLEAU_SITE
        - ENTITY_TYPE_AIRFLOW_DAG
        - ENTITY_TYPE_AIRFLOW_TASK
        - ENTITY_TYPE_CLICKHOUSE_TABLE
        - ENTITY_TYPE_CLICKHOUSE_VIEW
        - ENTITY_TYPE_ANOMALY_MONITOR
        - ENTITY_TYPE_ANOMALY_MONITOR_SEGMENT
        - ENTITY_TYPE_SQLTEST_TEST
        - ENTITY_TYPE_RECON_SUITE
        - ENTITY_TYPE_RECON_CASE
        - ENTITY_TYPE_LINEAGE_FOLD
        - ENTITY_TYPE_POSTGRES_TABLE
        - ENTITY_TYPE_POSTGRES_VIEW
        - ENTITY_TYPE_MYSQL_TABLE
        - ENTITY_TYPE_MYSQL_VIEW
        - ENTITY_TYPE_DATABRICKS_WAREHOUSE
        - ENTITY_TYPE_DATABRICKS_TABLE
        - ENTITY_TYPE_DATABRICKS_VIEW
        - ENTITY_TYPE_DATABRICKS_JOB
        - ENTITY_TYPE_DATABRICKS_JOB_TASK
        - ENTITY_TYPE_DATABRICKS_NOTEBOOK
        - ENTITY_TYPE_DATABRICKS_QUERY
        - ENTITY_TYPE_DATABRICKS_DASHBOARD
        - ENTITY_TYPE_DATABRICKS_METRIC_VIEW
        - ENTITY_TYPE_SQLMESH_PROJECT
        - ENTITY_TYPE_SQLMESH_SQL_MODEL
        - ENTITY_TYPE_SQLMESH_PYTHON_MODEL
        - ENTITY_TYPE_SQLMESH_EXTERNAL
        - ENTITY_TYPE_SQLMESH_SEED
        - ENTITY_TYPE_SQLMESH_AUDIT
        - ENTITY_TYPE_SQLMESH_UNIT_TEST
        - ENTITY_TYPE_SQLMESH_ENVIRONMENT
        - ENTITY_TYPE_SQLMESH_SNAPSHOT
        - ENTITY_TYPE_DUCKDB_TABLE
        - ENTITY_TYPE_DUCKDB_VIEW
        - ENTITY_TYPE_TRINO_TABLE
        - ENTITY_TYPE_TRINO_VIEW
        - ENTITY_TYPE_ATLAN_ASSET
        - ENTITY_TYPE_ATLAN_INTEGRATION
        - ENTITY_TYPE_COALESCE_PROJECT
        - ENTITY_TYPE_COALESCE_ENVIRONMENT
        - ENTITY_TYPE_COALESCE_NODE
        - ENTITY_TYPE_COALESCE_NODE_TEST
        - ENTITY_TYPE_COALESCE_JOB
        - ENTITY_TYPE_CASTORDOC_TABLE
        - ENTITY_TYPE_CASTORDOC_DASHBOARD
        - ENTITY_TYPE_CASTORDOC_VIEW
        - ENTITY_TYPE_CASTORDOC_TILE
        - ENTITY_TYPE_CASTORDOC_VIZ_MODEL
        - ENTITY_TYPE_POWERBI_REPORT
        - ENTITY_TYPE_POWERBI_TILE
        - ENTITY_TYPE_POWERBI_DATASET
        - ENTITY_TYPE_POWERBI_DASHBOARD
        - ENTITY_TYPE_POWERBI_TENANT
        - ENTITY_TYPE_THOUGHTSPOT_LIVEBOARD
        - ENTITY_TYPE_THOUGHTSPOT_WORKSHEET
        - ENTITY_TYPE_SIGMA_WORKBOOK
        - ENTITY_TYPE_SIGMA_DATA_MODEL
        - ENTITY_TYPE_SIGMA_ORGANIZATION
        - ENTITY_TYPE_DOMO_PAGE
        - ENTITY_TYPE_DOMO_DATASET
        - ENTITY_TYPE_MSSQL_TABLE
        - ENTITY_TYPE_MSSQL_VIEW
        - ENTITY_TYPE_ORACLE_TABLE
        - ENTITY_TYPE_ORACLE_VIEW
        - ENTITY_TYPE_ATHENA_TABLE
        - ENTITY_TYPE_ATHENA_VIEW
        - ENTITY_TYPE_FABRIC_TABLE
        - ENTITY_TYPE_FABRIC_VIEW
        - ENTITY_TYPE_DB2_TABLE
        - ENTITY_TYPE_DB2_VIEW
        - ENTITY_TYPE_LOOKER_STUDIO_CUSTOMER
        - ENTITY_TYPE_LOOKER_STUDIO_REPORT
        - ENTITY_TYPE_LOOKER_STUDIO_DATA_SOURCE
        - ENTITY_TYPE_CUSTOM_ENTITY_GENERIC
        - ENTITY_TYPE_CUSTOM_ENTITY_CUSTOM_TYPE_MIN
        - ENTITY_TYPE_CUSTOM_ENTITY_CUSTOM_TYPE_MAX
    synq.platforms.v1.DataPlatformType:
      type: string
      title: DataPlatformType
      enum:
        - DATA_PLATFORM_TYPE_UNSPECIFIED
        - DATA_PLATFORM_TYPE_BIGQUERY
        - DATA_PLATFORM_TYPE_LOOKER
        - DATA_PLATFORM_TYPE_DBT
        - DATA_PLATFORM_TYPE_DBT_CLOUD
        - DATA_PLATFORM_TYPE_DBT_SELF_HOSTED
        - DATA_PLATFORM_TYPE_SNOWFLAKE
        - DATA_PLATFORM_TYPE_GCP
        - DATA_PLATFORM_TYPE_GIT
        - DATA_PLATFORM_TYPE_GITHUB
        - DATA_PLATFORM_TYPE_REDSHIFT
        - DATA_PLATFORM_TYPE_TABLEAU
        - DATA_PLATFORM_TYPE_AIRFLOW
        - DATA_PLATFORM_TYPE_CLICKHOUSE
        - DATA_PLATFORM_TYPE_POSTGRES
        - DATA_PLATFORM_TYPE_MYSQL
        - DATA_PLATFORM_TYPE_DATABRICKS
        - DATA_PLATFORM_TYPE_SQLMESH
        - DATA_PLATFORM_TYPE_DUCKDB
        - DATA_PLATFORM_TYPE_TRINO
        - DATA_PLATFORM_TYPE_ATLAN
        - DATA_PLATFORM_TYPE_COALESCE
        - DATA_PLATFORM_TYPE_CASTORDOC
        - DATA_PLATFORM_TYPE_FIVETRAN
        - DATA_PLATFORM_TYPE_DAGSTER
        - DATA_PLATFORM_TYPE_AIRBYTE
        - DATA_PLATFORM_TYPE_STITCH
        - DATA_PLATFORM_TYPE_SNOWPLOW
        - DATA_PLATFORM_TYPE_POWERBI
        - DATA_PLATFORM_TYPE_THOUGHTSPOT
        - DATA_PLATFORM_TYPE_SIGMA
        - DATA_PLATFORM_TYPE_DOMO
        - DATA_PLATFORM_TYPE_MSSQL
        - DATA_PLATFORM_TYPE_ORACLE
        - DATA_PLATFORM_TYPE_ATHENA
        - DATA_PLATFORM_TYPE_FABRIC
        - DATA_PLATFORM_TYPE_DB2
        - DATA_PLATFORM_TYPE_LOOKER_STUDIO
        - DATA_PLATFORM_TYPE_HEX
        - DATA_PLATFORM_TYPE_OMNI
        - DATA_PLATFORM_TYPE_METABASE
        - DATA_PLATFORM_TYPE_GOOGLE_SHEETS
        - DATA_PLATFORM_TYPE_GRAFANA
        - DATA_PLATFORM_TYPE_STREAMLIT
        - DATA_PLATFORM_TYPE_ASTRATO
        - DATA_PLATFORM_TYPE_SNOWFLAKE_CORTEX
        - DATA_PLATFORM_TYPE_SNOWFLAKE_INTELLIGENCE
        - DATA_PLATFORM_TYPE_CUBE
        - DATA_PLATFORM_TYPE_CENSUS
        - DATA_PLATFORM_TYPE_HIGHTOUCH
        - DATA_PLATFORM_TYPE_WORKATO
        - DATA_PLATFORM_TYPE_ESTUARY
        - DATA_PLATFORM_TYPE_DLT
        - DATA_PLATFORM_TYPE_TERRAFORM
        - DATA_PLATFORM_TYPE_HEVO
        - DATA_PLATFORM_TYPE_DATASTREAM
        - DATA_PLATFORM_TYPE_SYNQ
    synq.queries.v1.QueryOperand:
      type: string
      title: QueryOperand
      enum:
        - QUERY_OPERAND_UNSPECIFIED
        - QUERY_OPERAND_AND
        - QUERY_OPERAND_OR
        - QUERY_OPERAND_EXCEPT
        - QUERY_OPERAND_UPSTREAM
        - QUERY_OPERAND_DOWNSTREAM
      description: >-
        QueryOperand defines how multiple QueryParts within a Query are
        combined.
    synq.datachecks.sqltests.v1.Severity:
      type: string
      title: Severity
      enum:
        - SEVERITY_UNSPECIFIED
        - SEVERITY_WARNING
        - SEVERITY_ERROR
        - SEVERITY_INFO
    synq.v1.Source:
      type: string
      title: Source
      enum:
        - SOURCE_APP
        - SOURCE_API
    synq.datachecks.sqltests.v1.GetSqlTestDeployOverviewResponse:
      type: object
      properties:
        overview:
          $ref: >-
            #/components/schemas/synq.datachecks.sqltests.v1.SqlTestsDeploymentOverview
      title: GetSqlTestDeployOverviewResponse
      additionalProperties: false
    synq.datachecks.sqltests.v1.SqlTestsDeploymentOverview:
      type: object
      properties:
        testsToCreate:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.SqlTestDeploymentChange
          description: Tests that would be newly created by this deploy.
        testsToUpdate:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.SqlTestDeploymentChange
          description: >-
            Tests that already exist and would be updated (e.g. a changed
            severity or
             template) by this deploy.
        testsToDelete:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.SqlTestDeploymentChange
          description: >-
            Tests that would be deleted by this deploy, because their table or
            view no
             longer matches the rule's selection.
        testsToKeep:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.SqlTestDeploymentChange
          description: Tests that already exist, still match, and would be left unchanged.
        skippedTables:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.SqlTestsDeploymentOverview.SkippedTable
          description: Tables or views this rule matched but could not deploy tests onto.
        skippedTests:
          type: array
          items:
            $ref: >-
              #/components/schemas/synq.datachecks.sqltests.v1.SqlTestsDeploymentOverview.SkippedTest
          description: >-
            Tests this rule declares that this deploy did not deploy — because
            another rule
             already owns them on the table, or because the table's columns do not support
             them.
        summary:
          $ref: >-
            #/components/schemas/synq.datachecks.sqltests.v1.SqlTestsDeploymentOverviewSummary
          description: >-
            Counts over the lists above, so a rule matching thousands of tables
            can be
             reported without reading every row. Always populated.
      title: SqlTestsDeploymentOverview
      additionalProperties: false
      description: |-
        SqlTestsDeploymentOverview previews or reports the effect of deploying a
         SqlTestDeploymentRule, per test rather than per table — a table with three
         tests deployed appears as three entries, one for each test.
    synq.datachecks.sqltests.v1.SqlTestDeploymentChange:
      type: object
      properties:
        tablePath:
          type: string
          description: Synq path of the table or view the test targets or would target.
        sqlTestPath:
          type: string
          description: >-
            Synq path of the SqlTest, when it already exists (create-side
            changes may
             leave this empty until the test is actually deployed).
        testName:
          type: string
          description: >-
            Name of the test, resolved from its RuleTest.name (or the generated
            name for
             non-business test kinds).
        reasonCode:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlTestSkipReason'
          description: >-
            Why this change happens, when the reason is something other than the
            rule's
             selection. Today that is one case: SQL_TEST_SKIP_REASON_MISSING_COLUMNS on a
             `tests_to_delete` entry whose table lost a column the test reads, so a caller can
             say "column dropped: amount" rather than reporting a bare delete. Unset
             (SQL_TEST_SKIP_REASON_UNSPECIFIED) otherwise, including for a delete caused by the
             table no longer matching the rule's selection — treat unset as "no extra reason",
             never as a list this change cannot appear in.
        missingColumns:
          type: array
          items:
            type: string
          description: >-
            Columns the table lacks, spelled as the test declares them, when
            `reason_code`
             is SQL_TEST_SKIP_REASON_MISSING_COLUMNS. Empty otherwise.
      title: SqlTestDeploymentChange
      additionalProperties: false
      description: >-
        SqlTestDeploymentChange describes one test's planned or applied change
        for a
         single table or view within a SqlTestsDeploymentOverview.
    synq.datachecks.sqltests.v1.SqlTestsDeploymentOverview.SkippedTable:
      type: object
      properties:
        tablePath:
          type: string
          description: Synq path of the skipped table or view.
        reason:
          type: string
          description: >-
            Why the table or view was skipped, as a stable SCREAMING_SNAKE
            token:

               SKIPPED_HIGHER_PRIORITY_RULE    an exclusive rule has carved the table out
               SKIPPED_NO_INTEGRATION          the table has no integration to run a test against
               SKIPPED_TEST_PREPARATION_FAILED the integration's configuration is unavailable,
                                               or the table's dialect cannot render the test

             Clients branch on these, so treat the spellings as part of this API: adding a
             value is safe, renaming one is a breaking change. A value not listed here may
             appear — fall through to "skipped, reason unrecognised" rather than assume the
             set is closed. `reason_code` is the checkable form.
        reasonCode:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlTestSkipReason'
          description: >-
            Machine-checkable form of `reason`, so a client can branch on a
            value the
             compiler knows instead of string-matching a wire constant. `reason` remains
             authoritative and keeps being written unchanged; `reason_code` is
             SQL_TEST_SKIP_REASON_UNSPECIFIED for a `reason` this enum does not yet cover.
      title: SkippedTable
      additionalProperties: false
      description: >-
        SkippedTable names a table or view the rule's selection matched, but
        that
         this deploy could not deploy tests onto.
    synq.datachecks.sqltests.v1.SqlTestsDeploymentOverview.SkippedTest:
      type: object
      properties:
        tablePath:
          type: string
          description: Synq path of the table or view carrying the test.
        sqlTestPath:
          type: string
          description: >-
            Synq path of the SqlTest, when it already exists (empty while the
            owning
             rule has not deployed it yet).
        testName:
          type: string
          description: >-
            Name of the test, resolved the same way as in
            SqlTestDeploymentChange.
        reason:
          type: string
          description: |-
            Why the test was skipped, as a stable SCREAMING_SNAKE token:

               SKIPPED_TEST_OWNED_BY_OTHER_RULE  another rule already deploys that test
               SKIPPED_MISSING_COLUMNS           the table lacks a column the test reads
               SKIPPED_SCHEMA_UNAVAILABLE        no schema is known for the table yet

             Clients branch on these, so treat the spellings as part of this API: adding a
             value is safe, renaming one is a breaking change. A value not listed here may
             appear — fall through to "skipped, reason unrecognised" rather than assume the
             set is closed. `reason_code` is the checkable form.
        ownerRuleId:
          type: string
          description: |-
            Id of the deployment rule that owns the test. Set only for
             SKIPPED_TEST_OWNED_BY_OTHER_RULE.
        ownerRuleTitle:
          type: string
          description: >-
            Title the owning rule carried when this plan was made. A title can
            be
             renamed — use owner_rule_id to look the rule up.
        reasonCode:
          $ref: '#/components/schemas/synq.datachecks.sqltests.v1.SqlTestSkipReason'
          description: |-
            Machine-checkable form of `reason`. Same contract as
             SkippedTable.reason_code: `reason` stays authoritative, and this is
             SQL_TEST_SKIP_REASON_UNSPECIFIED for a reason this enum does not yet cover.
        missingColumns:
          type: array
          items:
            type: string
          description: >-
            Columns the test reads that the table does not have, spelled as the
            test
             declares them. Set for SKIPPED_MISSING_COLUMNS; empty for every other reason.
             A test is skipped whole — `not_null[a, b]` with only `b` missing lists just
             `b` but deploys neither column — so this names the gap, not the test's
             column list.
        referencedTablePath:
          type: string
          description: >-
            Synq path of the *referenced* table, for a `relationships` test
            skipped
             because that table (rather than the table under test) lacks the column.
             Empty otherwise.
      title: SkippedTest
      additionalProperties: false
      description: >-
        SkippedTest names one test the rule declares that this deploy left in
        place
         rather than deploying, because another rule already deployed it on that table.
         Rules covering the same table merge additively: each deploys the tests that are
         not there yet, and never touches a test another rule owns.
    synq.datachecks.sqltests.v1.SqlTestsDeploymentOverviewSummary:
      type: object
      properties:
        tablesMatched:
          type: integer
          format: int32
          description: >-
            Distinct tables and views this plan touches: every table_path
            appearing in
             tests_to_create, tests_to_update, tests_to_delete, tests_to_keep,
             skipped_tests or skipped_tables, counted once.
        testsToCreate:
          type: integer
          format: int32
          description: len(tests_to_create).
        testsToUpdate:
          type: integer
          format: int32
          description: len(tests_to_update).
        testsToDelete:
          type: integer
          format: int32
          description: len(tests_to_delete).
        testsToKeep:
          type: integer
          format: int32
          description: len(tests_to_keep).
        testsSkipped:
          type: integer
          format: int32
          description: |-
            len(skipped_tests). Skipped *tables* are not counted here — see
             skipped_by_reason, which covers both lists. A test dropped because its column went
             away is a delete, not a skip, and counts in tests_to_delete.
        skippedByReason:
          type: object
          additionalProperties:
            type: integer
            title: value
            format: int32
          description: >-
            One entry per skip across BOTH skipped_tables and skipped_tests,
            keyed by the
             SqlTestSkipReason value name (e.g. "SQL_TEST_SKIP_REASON_MISSING_COLUMNS"), and
             "SQL_TEST_SKIP_REASON_UNSPECIFIED" for a reason string this enum does not cover.
             The two lists count in different units — a skipped table is one table, a skipped
             test is one test — so the values sum to more than `tests_skipped` whenever a
             table was skipped.
        missingColumnsHistogram:
          type: object
          additionalProperties:
            type: integer
            title: value
            format: int32
          description: >-
            Lowercased column name to the number of tests citing it as missing,
            counted over
             every entry carrying `missing_columns` — the skipped_tests the rule could not
             deploy AND the tests_to_delete it is removing because the column went away. Both
             answer the same question, "which columns does this rule not find", and a dropped
             column shows up as deletes rather than skips, so counting only one of the two
             reports an empty histogram for the case it exists for. A test missing two columns
             adds one to each. Lowercased so a column two tests spell differently is one entry.
             Empty when nothing cited a missing column.
      title: SqlTestsDeploymentOverviewSummary
      additionalProperties: false
      description: >-
        SqlTestsDeploymentOverviewSummary counts a SqlTestsDeploymentOverview,
        so a
         caller can render "40 tables, 78 tests, 2 skipped for a missing column" without
         walking lists that run to thousands of entries for a warehouse-wide rule. Every
         count is derived from the lists in the same message — it adds no information a
         reader of those lists could not compute, only the ability to skip reading them.
    synq.datachecks.sqltests.v1.SqlTestSkipReason:
      type: string
      title: SqlTestSkipReason
      enum:
        - SQL_TEST_SKIP_REASON_UNSPECIFIED
        - SQL_TEST_SKIP_REASON_HIGHER_PRIORITY_RULE
        - SQL_TEST_SKIP_REASON_NO_INTEGRATION
        - SQL_TEST_SKIP_REASON_TEST_PREPARATION_FAILED
        - SQL_TEST_SKIP_REASON_TEST_OWNED_BY_OTHER_RULE
        - SQL_TEST_SKIP_REASON_MISSING_COLUMNS
        - SQL_TEST_SKIP_REASON_SCHEMA_UNAVAILABLE
      description: >-
        SqlTestSkipReason is the checkable form of the `reason` string carried
        by
         SqlTestsDeploymentOverview.SkippedTable and .SkippedTest, mirroring the
         SCREAMING_SNAKE tokens documented on those fields one-for-one. It also carries
         the reason a SqlTestDeploymentChange deletes a test, which has no string form.
         The set is open by design — a producer may report a reason before this enum has
         a matching value for it — so a client must treat SQL_TEST_SKIP_REASON_UNSPECIFIED
         (and any value this client predates) as "skipped, reason unrecognised" rather
         than as proof nothing applies.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````

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