> ## 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. # BatchGet > Get multiple alert configurations by their identifiers. ## OpenAPI ````yaml /api-reference/openapi.yaml post /api/alerts/v2/get 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.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.ingest.cloudwatch.v1.CloudwatchService - name: synq.ingest.dwh.v1.DwhService - name: synq.ingest.openlineage.v1.OpenlineageService - name: synq.ingest.airflow.v1.AirflowLogsService - 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.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.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.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 all three once at startup, keeps them in a map, and looks types up as responses arrive. 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 and ListExecutionTypeDefs 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.entities.v1.EntitiesService description: EntitiesService is a service for retriving any entity. - 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.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.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.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.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.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" and "what SQL constructs does this specific entity use", without requiring the caller to re-parse any SQL. - name: synq.entities.orchestration.v1.OrchestrationService description: >- OrchestrationService provides information about orchestration relationships between entities. This includes relationships between Airflow tasks and transformation models (dbt, SQLMesh), as well as task-to-task dependencies. - name: synq.entities.resolve.v1.IdentifierResolveService description: >- IdentifierResolveService resolves identifiers to their Coalesce Quality paths and identities. - 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.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.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.lineage.v1.LineageService description: |- LineageService allows you to fetch: * Entity level lineage from a starting point of one or more entities. * Column Level lineage from a starting point of multiple columns of a single entity. - name: synq.entities.custom.v1.EntityExecutionsService - name: synq.entities.custom.v1.GroupsService description: >- It eliminates the need to keep state on client side to remember which assets were already created and which should be deleted. The server will keep track of the current state of the group and client can always send the intended new state. The server will calculate the diff and entities that are no longer present in the group will be removed. Example: 1. group has entities A, B, C at time t1 2. client sends group with entities B, C, D at time t2 3. server will remove entity A from the system and update the current state of the group to B, C, D The service is designed to be idempotent and can be called multiple times with the same state without causing any side effects. - name: synq.entities.custom.v1.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.TypesService description: TypesService is a service for managing custom entity types. - 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.FeaturesService - name: synq.entities.impact.v1.ImpactService - name: synq.entities.executions.v1.EntityExecutionsService description: 'Deprecated: Use [synq.entities.custom.v1.EntityExecutionsService] instead' - 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.coordinates.v1.DatabaseCoordinatesService description: >- DatabaseCoordinatesService is a service for getting database coordinates of Entities. - 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.monitors.history.v1.HistoryService - name: synq.monitors.info.v1.MonitorInfoService - name: synq.monitors.predictions.v1.MonitorPredictionsService description: Access to anomaly detection model predictions and raw metric timeseries. - name: synq.monitors.automated_monitors.v1.DeploymentRulesService - name: synq.monitors.custom_monitors.v1.CustomMonitorsService - 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.queries.v1.NLQueryService description: >- NLQueryService generates structured Query protos from natural language descriptions using an LLM. - 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. - 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 - 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.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.dataproducts.v1.DataproductsService description: DataproductsService can be used to manage data products. - 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.schedule.v1.ScheduleService description: ScheduleService provides schedule evaluation utilities. - 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.v1.AlertsService` (how the configured alerts are reported), and `synq.users.v1.UsersService` (resolve the users behind `UserContact` and Slack/Teams mentions). - 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.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.platforms.v1.PlatformsService description: PlatformsService is a service for managing Platforms and Integrations. - name: synq.incidents.v1.IncidentsService description: IncidentsService is a service for managing Incidents. - name: synq.git.commits.v1.CommitsService - name: synq.domains.v1.DomainsService description: DomainsService can be used to manage domains. - 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.extensions.atlan.integrations.v1.AtlanIntegrationService - name: synq.extensions.atlan.workflows.v1.AtlanWorkflowService - name: synq.extensions.atlan.provider.v1.AtlanProviderService paths: /api/alerts/v2/get: post: tags: - synq.alerts.services.v2.AlertsService summary: BatchGet description: Get multiple alert configurations by their identifiers. operationId: synq.alerts.services.v2.AlertsService.BatchGet requestBody: content: application/json: schema: $ref: '#/components/schemas/synq.alerts.services.v2.BatchGetRequest' required: true responses: '200': description: Success content: application/json: schema: $ref: '#/components/schemas/synq.alerts.services.v2.BatchGetResponse' components: schemas: synq.alerts.services.v2.BatchGetRequest: type: object properties: identifiers: type: array items: $ref: '#/components/schemas/synq.alerts.services.v2.AlertIdentifier' minItems: 1 description: IDs of the alerts to get. title: BatchGetRequest additionalProperties: false synq.alerts.services.v2.BatchGetResponse: type: object properties: alerts: type: object additionalProperties: $ref: '#/components/schemas/synq.alerts.v2.Alert' title: value description: Alerts mapped by their identifiers. title: BatchGetResponse additionalProperties: false synq.alerts.services.v2.AlertIdentifier: type: object oneOf: - properties: fqn: type: string title: fqn maxLength: 500 minLength: 1 description: FQN of the alert configuration to update. title: fqn required: - fqn - properties: id: type: string title: id minLength: 1 description: ID of the alert configuration to update. title: id required: - id additionalProperties: false synq.alerts.v2.Alert: type: object properties: id: type: string minLength: 1 description: Unique identifier for the alert config (system-generated). name: type: string maxLength: 255 minLength: 1 description: Human-readable name for the alert configuration. fqn: type: string maxLength: 500 minLength: 1 description: |- User-provided fully qualified name for the alert config. This is a unique identifier that users can specify to reference the alert. nullable: true trigger: $ref: '#/components/schemas/synq.alerts.v2.Trigger' description: Selects the entities that can trigger this alert. targets: type: array items: $ref: '#/components/schemas/synq.alerts.v2.AlertingTarget' minItems: 1 description: List of targets where alerts will be sent. settings: $ref: '#/components/schemas/synq.alerts.v2.AlertSettings' description: Additional settings for the specific alert type. owner: $ref: '#/components/schemas/synq.alerts.v2.Alert.Owner' nullable: true createdAt: $ref: '#/components/schemas/google.protobuf.Timestamp' description: Timestamp when the alert config was created. isDisabled: type: boolean description: Whether the alert config is currently disabled. title: Alert required: - trigger - settings - createdAt additionalProperties: false description: |- Alert represents the configuration for an alert. It contains all the necessary information to trigger and send alerts. synq.alerts.v2.Trigger: type: object properties: query: $ref: '#/components/schemas/synq.queries.v1.Query' description: >- Structured selection of the entities that can trigger this alert. On write it is the selection unless `resolver_ql` is set, which takes precedence. Always populated on read, best-effort — a part with no public form is carried as `unsupported`. resolverQl: type: string maxLength: 20000 description: >- ResolverQL selection string, a more expressive alternative to `query` for selections it cannot express (e.g. lineage walks, column predicates). When set on write it takes precedence and `query` is ignored. On read it is echoed back verbatim for alerts authored via ResolverQL and empty for structured alerts, so writing a read response back unchanged preserves the authored form. See `rendered_resolver_ql` for the ResolverQL form of a structured alert. renderedResolverQl: type: string description: >- Output-only canonical ResolverQL rendering of this alert's selection, populated regardless of how it was authored (it equals `resolver_ql` for ResolverQL-authored alerts). Ignored on write. Empty only for selections with no ResolverQL representation. title: Trigger additionalProperties: false description: > Trigger selects the entities whose issues or schema changes fire this alert: a structured `query`, an optional ResolverQL string that takes precedence when set, and a read-only canonical rendering. trigger.requires_selection // at least one of query or resolver_ql must be set synq.alerts.v2.AlertingTarget: type: object oneOf: - properties: email: $ref: '#/components/schemas/synq.alerts.v2.EmailTarget' title: email description: Send alert via email. title: email required: - email - properties: msTeams: $ref: '#/components/schemas/synq.alerts.v2.MsTeamsTarget' title: ms_teams description: Send alert to Microsoft Teams channel or member. title: ms_teams required: - msTeams - properties: owner: $ref: '#/components/schemas/synq.alerts.v2.OwnerTarget' title: owner description: Send alert to the owner of the monitored entity. title: owner required: - owner - properties: slack: $ref: '#/components/schemas/synq.alerts.v2.SlackTarget' title: slack description: Send alert to a Slack channel or user. title: slack required: - slack - properties: webhook: $ref: '#/components/schemas/synq.alerts.v2.WebhookTarget' title: webhook description: Send alert via webhook integration. title: webhook required: - webhook additionalProperties: false description: >- AlertingTarget represents a destination where alert notifications will be sent. Each target type has its own specific configuration requirements. synq.alerts.v2.AlertSettings: type: object oneOf: - properties: issue: $ref: '#/components/schemas/synq.alerts.v2.IssueAlertSettings' title: issue description: Unified issue alert settings. title: issue required: - issue - properties: schemaChange: $ref: '#/components/schemas/synq.alerts.v2.SchemaChangeAlertSettings' title: schema_change description: Alert triggered by schema changes. title: schema_change required: - schemaChange additionalProperties: false description: >- AlertSettings defines the properties that affect the trigger and presentation of an alert. It specifies the conditions under which an alert should be fired and how it should behave. synq.alerts.v2.Alert.Owner: type: object properties: ownerPath: type: string minLength: 1 description: Path identifying the owner of this alert config. ownershipId: type: string minLength: 1 description: Ownership identifier. title: Owner additionalProperties: false description: |- Owner information for the alert configuration. If set, the alert is attributed to the specified owner and ownership. google.protobuf.Timestamp: type: string examples: - '2023-01-15T01:30:15.01Z' - '2024-12-25T12:00:00Z' format: date-time description: >- A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # Examples Example 1: Compute Timestamp from POSIX `time()`. Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); Example 2: Compute Timestamp from POSIX `gettimeofday()`. struct timeval tv; gettimeofday(&tv, NULL); Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. long millis = System.currentTimeMillis(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); Example 5: Compute Timestamp from Java `Instant.now()`. Instant now = Instant.now(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(now.getEpochSecond()) .setNanos(now.getNano()).build(); Example 6: Compute Timestamp from current time in Python. timestamp = Timestamp() timestamp.GetCurrentTime() # JSON Mapping In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. synq.queries.v1.Query: type: object properties: parts: type: array items: $ref: '#/components/schemas/synq.queries.v1.Query.QueryPart' operand: $ref: '#/components/schemas/synq.queries.v1.QueryOperand' description: Defaults to AND if not specified. title: Query additionalProperties: false description: > Query is a structured query that can be used to find entities in the system. It consists of multiple parts, each representing a different filter or sub-query. The parts are combined using the operand to form the final result: - AND (default): returns only entities matching ALL parts (intersection). - OR: returns entities matching ANY part (union). - EXCEPT: requires exactly 2 parts — returns entities from part[0] that are NOT in part[1]. - UPSTREAM: returns entities that are upstream (dependencies) of the entities matched by the parts. - DOWNSTREAM: returns entities that are downstream (dependents) of the entities matched by the parts. Queries can be nested by using a Query as a QueryPart, enabling complex compositions like "upstream of all Snowflake tables". query.except_parts_select_something // each QUERY_OPERAND_EXCEPT part must select something query.except_requires_two_parts // QUERY_OPERAND_EXCEPT requires exactly 2 parts synq.alerts.v2.EmailTarget: type: object properties: recipientEmails: type: array items: type: string format: email minItems: 1 minItems: 1 description: |- List of email addresses that will receive the alert notifications. Each email must be a valid email address format. title: EmailTarget additionalProperties: false description: EmailTarget configures alert delivery via email. synq.alerts.v2.MsTeamsTarget: type: object properties: channel: type: string minLength: 1 description: Teams channel name or ID. title: MsTeamsTarget additionalProperties: false description: |- MsTeamsTarget configures alert delivery to Microsoft Teams. Alerts are sent to a Microsoft Teams channel. synq.alerts.v2.OwnerTarget: type: object properties: ownerPath: type: string minLength: 1 description: |- Path that identifies the ownership context for this target. This determines how the system will resolve the actual owner. title: OwnerTarget additionalProperties: false description: >- OwnerTarget configures alert delivery to the owner of the monitored entity. This allows alerts to be automatically sent to whoever owns the data being monitored. synq.alerts.v2.SlackTarget: type: object properties: channel: type: string minLength: 1 description: Slack channel name or ID (e.g., "#alerts" or "C1234567890"). title: SlackTarget additionalProperties: false description: |- SlackTarget configures alert delivery to Slack. Alerts are sent to a Slack channel. synq.alerts.v2.WebhookTarget: type: object properties: webhookId: type: string minLength: 1 description: |- Unique identifier of the webhook to send alerts to. This references a pre-configured webhook in the system. title: WebhookTarget additionalProperties: false description: |- WebhookTarget configures alert delivery via webhook/hook integrations. This allows integration with external systems and custom notification workflows. synq.alerts.v2.IssueAlertSettings: type: object properties: severities: type: array items: $ref: '#/components/schemas/synq.v1.Severity' minItems: 1 description: The severity levels that should trigger this alert. notifyUpstream: type: boolean description: Whether to notify upstream dependencies when this alert triggers. allowSqlTestAuditLink: type: boolean description: Whether to allow SQL test audit links in alert notifications. ongoing: $ref: '#/components/schemas/synq.alerts.v2.OngoingAlertsStrategy' description: Strategy for handling ongoing/repeated alerts. grouping: $ref: '#/components/schemas/synq.alerts.v2.IssueGroupingStrategy' description: Strategy for grouping issues in alert notifications. title: IssueAlertSettings required: - ongoing additionalProperties: false description: >- IssueAlertSettings is the unified alert settings type for issue-based alerts. synq.alerts.v2.SchemaChangeAlertSettings: type: object properties: notifyUpstream: type: boolean description: Whether to notify upstream dependencies when schema changes occur. ongoing: $ref: '#/components/schemas/synq.alerts.v2.OngoingAlertsStrategy' description: >- Delivery strategy. Unset or stream sends one alert per schema change; a schedule batches them into a periodic digest on the given cron cadence. title: SchemaChangeAlertSettings additionalProperties: false description: > SchemaChangeAlertSettings configures alerts for schema changes. This alert triggers when the schema of monitored entities changes. schema_change_alert_settings.ongoing_disabled_unsupported // Schema change alerts do not support the disabled ongoing strategy. Leave ongoing unset for per-change streaming, or set stream or schedule. synq.queries.v1.Query.QueryPart: type: object oneOf: - properties: entityIds: $ref: '#/components/schemas/synq.queries.v1.EntityIds' title: entity_ids description: >- Pin specific entities by the ids the API returned for them. Read back as `identifier_list`, with each id on the identifier it names. title: entity_ids required: - entityIds - properties: identifierList: $ref: '#/components/schemas/synq.queries.v1.IdentifierList' title: identifier_list title: identifier_list required: - identifierList - properties: identitiesOf: $ref: '#/components/schemas/synq.queries.v1.IdentitiesOf' title: identities_of title: identities_of required: - identitiesOf - properties: inDataPlatform: $ref: '#/components/schemas/synq.queries.v1.InDataPlatform' title: in_data_platform title: in_data_platform required: - inDataPlatform - properties: inDataproduct: $ref: '#/components/schemas/synq.queries.v1.InDataproduct' title: in_dataproduct title: in_dataproduct required: - inDataproduct - properties: inDomain: $ref: '#/components/schemas/synq.queries.v1.InDomain' title: in_domain title: in_domain required: - inDomain - properties: inFolder: $ref: '#/components/schemas/synq.queries.v1.InFolder' title: in_folder title: in_folder required: - inFolder - properties: query: $ref: '#/components/schemas/synq.queries.v1.Query' title: query description: >- Nested sub-query, enabling recursive composition of filters and operands. title: query required: - query - properties: unsupported: $ref: '#/components/schemas/synq.queries.v1.Unsupported' title: unsupported description: >- Read-only. Represents internal query types that cannot be expressed in the public API. Do not construct these directly — they are returned when translating from internal queries. title: unsupported required: - unsupported - properties: withAnnotation: $ref: '#/components/schemas/synq.queries.v1.WithAnnotation' title: with_annotation title: with_annotation required: - withAnnotation - properties: withDataPlatformType: $ref: '#/components/schemas/synq.queries.v1.WithDataPlatformType' title: with_data_platform_type title: with_data_platform_type required: - withDataPlatformType - properties: withDefaultVisibleTypes: $ref: '#/components/schemas/synq.queries.v1.WithDefaultVisibleTypes' title: with_default_visible_types title: with_default_visible_types required: - withDefaultVisibleTypes - properties: withNameSearch: $ref: '#/components/schemas/synq.queries.v1.WithNameSearch' title: with_name_search title: with_name_search required: - withNameSearch - properties: withType: $ref: '#/components/schemas/synq.queries.v1.WithType' title: with_type title: with_type required: - withType additionalProperties: false 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.v1.Severity: type: string title: Severity enum: - SEVERITY_UNSPECIFIED - SEVERITY_WARN - SEVERITY_ERROR - SEVERITY_FATAL synq.alerts.v2.OngoingAlertsStrategy: type: object oneOf: - properties: disabled: $ref: >- #/components/schemas/synq.alerts.v2.OngoingAlertsStrategy.Disabled title: disabled title: disabled required: - disabled - properties: schedule: $ref: >- #/components/schemas/synq.alerts.v2.OngoingAlertsStrategy.Schedule title: schedule title: schedule required: - schedule - properties: stream: $ref: '#/components/schemas/synq.alerts.v2.OngoingAlertsStrategy.Stream' title: stream title: stream required: - stream additionalProperties: false description: |- OngoingAlertsStrategy defines how to handle ongoing/repeated alerts. This prevents alert spam by controlling notification frequency. synq.alerts.v2.IssueGroupingStrategy: type: object oneOf: - properties: noGrouping: $ref: >- #/components/schemas/synq.alerts.v2.IssueGroupingStrategy.NoGrouping title: no_grouping title: no_grouping required: - noGrouping - properties: systemDetected: $ref: >- #/components/schemas/synq.alerts.v2.IssueGroupingStrategy.SystemDetected title: system_detected title: system_detected required: - systemDetected additionalProperties: false description: >- IssueGroupingStrategy controls how issues are grouped for alerting purposes. synq.queries.v1.EntityIds: type: object properties: entityIds: type: array items: type: string maxLength: 1024 minLength: 1 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. title: EntityIds additionalProperties: false description: >- Selects exactly the entities you list, by the `entity_id` the API returned for each of them. This is the pin-these-specific-entities part of a query: the assets a user ticked in a list, the results of a search you just ran, the entities another API call handed you. Because you pass the ids back as they were given, you do not need to know what kind of entity each one is, or how its address in the source system is spelled. `identifier_list` is the alternative, and the choice between them is about what you have in hand: - `entity_ids` — you are holding ids the API gave you. Pass them through unchanged. - `identifier_list` — you are naming entities by their address in the source system (a BigQuery project/dataset/table, a dbt model, a Looker explore), for example because a person or a config file wrote it down rather than an API call. **Reading back a selection you wrote with `entity_ids`.** Selections are always returned as `identifier_list`, whichever of the two you sent — one uniform shape, so integrations built before `entity_ids` existed keep reading stored queries unchanged. Your ids are not lost in the process: every returned identifier carries its `entity_id`, so you can match each one back to what you sent, and compare a saved selection against the one you are about to save. The returned id is the entity's canonical form, which can differ from an equivalent spelling you sent for the same entity. **An id that matches nothing selects nothing**, and is not an error — so a saved query keeps working after one of the entities it names is deleted or renamed, rather than failing every time it is read or resolved. synq.queries.v1.IdentifierList: type: object properties: identifiers: type: array items: $ref: '#/components/schemas/synq.entities.v1.Identifier' title: IdentifierList additionalProperties: false description: Resolves to entities matching any of the given identifiers. synq.queries.v1.IdentitiesOf: type: object properties: inputQuery: $ref: '#/components/schemas/synq.queries.v1.Query' description: The assets whose identities to resolve. Required. limitToTypes: type: array items: $ref: '#/components/schemas/synq.queries.v1.WithType.Type' description: >- Restrict the result to these types. When empty, only the other members of each identity group are returned. When set, an input asset that already has one of these types is returned as well. title: IdentitiesOf required: - inputQuery additionalProperties: false description: > Resolves to the identities of whatever the inner query matches. The same real-world table is often described by several assets — a transformation model and the warehouse table it materialises into are one asset with several representations. Those representations form an identity group. IdentitiesOf takes the assets matched by `input_query` and returns their identity groups, so a selection made in one platform's terms also covers the equivalent assets in every other platform. The typical use is subtraction: "this warehouse database, except whatever my transformation tool already owns" is an EXCEPT whose removal clause is an IdentitiesOf over the transformation models. Without it the two selections overlap on every materialised table. identities_of.input_query_selects_something // identities_of requires an input_query with at least one part synq.queries.v1.InDataPlatform: type: object properties: identifier: $ref: '#/components/schemas/synq.platforms.v1.DataPlatformIdentifier' title: InDataPlatform additionalProperties: false description: Resolves to all entities that belong to the given data platform. synq.queries.v1.InDataproduct: type: object properties: identifier: $ref: '#/components/schemas/synq.entities.v1.DataproductIdentifier' title: InDataproduct additionalProperties: false description: Resolves to all the assets that belong to the given data product. synq.queries.v1.InDomain: type: object properties: domainId: type: string format: uuid title: InDomain additionalProperties: false description: Resolves to all entities in the given data domain. synq.queries.v1.InFolder: type: object properties: path: type: array items: type: string 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. folders: type: array items: $ref: '#/components/schemas/synq.entities.v1.FolderRef' description: >- Structured, human-authorable folder addresses (root entity + folder-name segments). Take a `FolderRef` verbatim from a folder returned by the folders navigation API, or build one from names you can see in the catalog. folderOf: $ref: '#/components/schemas/synq.queries.v1.FolderOf' description: >- Resolve the folders to search from a set of assets, rather than naming them. Selects everything in the folder(s) that contain those assets. deep: type: boolean 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). nullable: true title: InFolder additionalProperties: false description: > Resolves to entities located in one or more folders. Give the folders exactly one way (they are mutually exclusive; if more than one is set, `folders` wins, then `folder_of`, then `path`): - `folders` — the preferred, human-authorable form: name each folder by its root entity plus its ordered folder-name segments. No opaque ids required. - `folder_of` — "the same folder(s) as these assets": resolves the folder(s) containing the assets matched by an inner query, then matches everything in them. Lets you select siblings without naming a folder. - `path` — legacy opaque folder identifiers. Kept for back-compat; prefer `folders`. Discover a folder's structured address with the folders navigation API instead of hand-writing an id. `deep` controls recursion (see its field comment). InFolder lives here rather than in query_parts.proto because FolderOf nests a full Query, which would make query_parts.proto import query.proto and form a proto file import cycle. in_folder.exactly_one_source // set exactly one of path, folders, or folder_of synq.queries.v1.Unsupported: type: object properties: queryJson: type: string title: Unsupported additionalProperties: false description: >- Collects all the parts of the query that are currently unsupported in translation. These represent an internal structure that are not yet completely available on the API. synq.queries.v1.WithAnnotation: type: object properties: name: type: string acceptedValue: type: string nullable: true deprecated: true acceptedValues: type: array items: type: string title: WithAnnotation additionalProperties: false description: >- Resolves to all entities that contain the annotation with at least one of the provided accepted values. In case of no given accepted values, all entities that carry the given annotation are returned. synq.queries.v1.WithDataPlatformType: type: object properties: types: type: array items: $ref: '#/components/schemas/synq.platforms.v1.DataPlatformType' title: WithDataPlatformType additionalProperties: false synq.queries.v1.WithDefaultVisibleTypes: type: object title: WithDefaultVisibleTypes additionalProperties: false description: |- Resolves to every asset of a type the catalog shows by default — the "everything" starting set. Use it as the base of a subtraction, e.g. an EXCEPT query whose first part is WithDefaultVisibleTypes and whose second part is what to leave out. On its own it selects the whole catalog, so it is rarely useful as the only part of a query. "Default visible" excludes the supporting asset types the catalog hides unless asked for (columns, tests, and similar), so this is not literally every entity. synq.queries.v1.WithNameSearch: type: object properties: searchQuery: type: string title: WithNameSearch additionalProperties: false description: Resolves to all entities matching the given name search. synq.queries.v1.WithType: type: object properties: type: $ref: '#/components/schemas/synq.queries.v1.WithType.Type' deprecated: true types: type: array items: $ref: '#/components/schemas/synq.queries.v1.WithType.Type' traits: type: array items: type: string 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. title: WithType additionalProperties: false description: >- Resolves to all the entities that have the provided type, or carry one of the provided traits. synq.alerts.v2.OngoingAlertsStrategy.Disabled: type: object title: Disabled additionalProperties: false description: >- Disabled strategy - no ongoing alerts will be sent after the initial alert. No configuration needed - alerts are simply disabled after the first one. synq.alerts.v2.OngoingAlertsStrategy.Schedule: type: object properties: cron: type: string minLength: 1 description: |- Cron expression defining when ongoing alerts should be sent. Must be a valid cron expression (e.g., "0 9 * * MON" for every Monday at 9 AM). title: Schedule additionalProperties: false description: Schedule strategy - alerts are sent on a scheduled basis. synq.alerts.v2.OngoingAlertsStrategy.Stream: type: object title: Stream additionalProperties: false description: >- Stream strategy - alerts are sent continuously as issues persist. No configuration needed - alerts stream continuously. synq.alerts.v2.IssueGroupingStrategy.NoGrouping: type: object title: NoGrouping additionalProperties: false description: NoGrouping - each issue triggers a separate alert. synq.alerts.v2.IssueGroupingStrategy.SystemDetected: type: object title: SystemDetected additionalProperties: false description: SystemDetected - the system automatically groups related issues. synq.entities.v1.Identifier: type: object allOf: - properties: entityId: 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. - oneOf: - properties: airflowDag: $ref: '#/components/schemas/synq.entities.v1.AirflowDagIdentifier' title: airflow_dag description: Airflow DAG identifier title: airflow_dag required: - airflowDag - properties: airflowTask: $ref: '#/components/schemas/synq.entities.v1.AirflowTaskIdentifier' title: airflow_task description: Airflow task identifier within a given DAG title: airflow_task required: - airflowTask - properties: athenaTable: $ref: '#/components/schemas/synq.entities.v1.AthenaTableIdentifier' title: athena_table description: Amazon Athena (Glue) table identifier title: athena_table required: - athenaTable - properties: bigqueryTable: $ref: >- #/components/schemas/synq.entities.v1.BigqueryTableIdentifier title: bigquery_table description: BigQuery table identifier title: bigquery_table required: - bigqueryTable - properties: clickhouseTable: $ref: >- #/components/schemas/synq.entities.v1.ClickhouseTableIdentifier title: clickhouse_table description: Clickhouse table identifier title: clickhouse_table required: - clickhouseTable - properties: custom: $ref: '#/components/schemas/synq.entities.v1.CustomIdentifier' title: custom description: >- Custom identifier to be used with all custom created entities title: custom required: - custom - properties: databricksTable: $ref: >- #/components/schemas/synq.entities.v1.DatabricksTableIdentifier title: databricks_table description: Databricks table identifier title: databricks_table required: - databricksTable - properties: dataproduct: $ref: '#/components/schemas/synq.entities.v1.DataproductIdentifier' title: dataproduct description: Dataproduct identifier title: dataproduct required: - dataproduct - properties: dbtCloudNode: $ref: '#/components/schemas/synq.entities.v1.DbtCloudNodeIdentifier' title: dbt_cloud_node description: >- Dbt node that identifies one of dbt DAG nodes (model, test, etc) in dbt Cloud project title: dbt_cloud_node required: - dbtCloudNode - properties: dbtCoreNode: $ref: '#/components/schemas/synq.entities.v1.DbtCoreNodeIdentifier' title: dbt_core_node description: >- Dbt node that identifies one of dbt DAG nodes (model, test, etc) in dbt Core project title: dbt_core_node required: - dbtCoreNode - properties: fabricTable: $ref: '#/components/schemas/synq.entities.v1.FabricTableIdentifier' title: fabric_table description: Microsoft Fabric table identifier title: fabric_table required: - fabricTable - properties: monitor: $ref: '#/components/schemas/synq.entities.v1.MonitorIdentifier' title: monitor description: Monitor identifier title: monitor required: - monitor - properties: mssqlTable: $ref: '#/components/schemas/synq.entities.v1.MssqlTableIdentifier' title: mssql_table description: SQL Server table identifier title: mssql_table required: - mssqlTable - properties: mysqlTable: $ref: '#/components/schemas/synq.entities.v1.MysqlTableIdentifier' title: mysql_table description: Mysql table identifier title: mysql_table required: - mysqlTable - properties: oracleTable: $ref: '#/components/schemas/synq.entities.v1.OracleTableIdentifier' title: oracle_table description: Oracle table identifier title: oracle_table required: - oracleTable - properties: postgresTable: $ref: >- #/components/schemas/synq.entities.v1.PostgresTableIdentifier title: postgres_table description: Postgres table identifier title: postgres_table required: - postgresTable - properties: redshiftTable: $ref: >- #/components/schemas/synq.entities.v1.RedshiftTableIdentifier title: redshift_table description: Redshift table identifier title: redshift_table required: - redshiftTable - properties: savedView: $ref: '#/components/schemas/synq.entities.v1.SavedViewIdentifier' title: saved_view description: Saved view identifier title: saved_view required: - savedView - properties: snowflakeTable: $ref: >- #/components/schemas/synq.entities.v1.SnowflakeTableIdentifier title: snowflake_table description: Snowflake table identifier title: snowflake_table required: - snowflakeTable - properties: sqlMeshAudit: $ref: '#/components/schemas/synq.entities.v1.SqlMeshAuditIdentifier' title: sql_mesh_audit description: SQLMesh Audit identifier title: sql_mesh_audit required: - sqlMeshAudit - properties: sqlMeshModel: $ref: '#/components/schemas/synq.entities.v1.SqlMeshModelIdentifier' title: sql_mesh_model description: SQLMesh Model identifier title: sql_mesh_model required: - sqlMeshModel - properties: synqPath: $ref: '#/components/schemas/synq.entities.v1.SynqPathIdentifier' title: synq_path description: SynqPath identifier title: synq_path required: - synqPath - properties: trinoTable: $ref: '#/components/schemas/synq.entities.v1.TrinoTableIdentifier' title: trino_table description: Trino table identifier title: trino_table required: - trinoTable title: Identifier additionalProperties: false description: >- Identifier is a unique reference to an entity in Coalesce Quality system. Entity identifiers are designed to closely mimic identifiers used by data platforms and tools. To construct an identifier, you need to know the kind of the entity and the ids that you would normally use to identify it in the data platform or tool. For example, to identify a table in BigQuery, you would need to know the project, dataset, and table names. Every identifier the API RETURNS also carries `entity_id`, the entity's opaque id. Read it when you just need to name the entity again — it is one string for every platform, where the structured variants below only cover the platforms that have one. synq.queries.v1.WithType.Type: type: object oneOf: - properties: custom: type: integer title: custom format: int32 description: >- Custom types as defined through synq.entities.custom.v1.TypesService title: custom required: - custom - properties: default: $ref: '#/components/schemas/synq.entities.v1.EntityType' title: default description: Default Coalesce Quality types title: default required: - default additionalProperties: false synq.platforms.v1.DataPlatformIdentifier: type: object oneOf: - properties: athena: $ref: '#/components/schemas/synq.platforms.v1.AthenaIdentifier' title: athena title: athena required: - athena - properties: bigquery: $ref: '#/components/schemas/synq.platforms.v1.BigqueryIdentifier' title: bigquery title: bigquery required: - bigquery - properties: clickhouse: $ref: '#/components/schemas/synq.platforms.v1.ClickhouseIdentifier' title: clickhouse title: clickhouse required: - clickhouse - properties: databricks: $ref: '#/components/schemas/synq.platforms.v1.DatabricksIdentifier' title: databricks title: databricks required: - databricks - properties: dbtCloud: $ref: '#/components/schemas/synq.platforms.v1.DbtCloudIdentifier' title: dbt_cloud title: dbt_cloud required: - dbtCloud - properties: duckdb: $ref: '#/components/schemas/synq.platforms.v1.DuckDbIdentifier' title: duckdb title: duckdb required: - duckdb - properties: fabric: $ref: '#/components/schemas/synq.platforms.v1.FabricIdentifier' title: fabric title: fabric required: - fabric - properties: mssql: $ref: '#/components/schemas/synq.platforms.v1.MssqlIdentifier' title: mssql title: mssql required: - mssql - properties: mysql: $ref: '#/components/schemas/synq.platforms.v1.MysqlIdentifier' title: mysql title: mysql required: - mysql - properties: oracle: $ref: '#/components/schemas/synq.platforms.v1.OracleIdentifier' title: oracle title: oracle required: - oracle - properties: postgres: $ref: '#/components/schemas/synq.platforms.v1.PostgresIdentifier' title: postgres title: postgres required: - postgres - properties: redshift: $ref: '#/components/schemas/synq.platforms.v1.RedshiftIdentifier' title: redshift title: redshift required: - redshift - properties: snowflake: $ref: '#/components/schemas/synq.platforms.v1.SnowflakeIdentifier' title: snowflake title: snowflake required: - snowflake - properties: sqlMesh: $ref: '#/components/schemas/synq.platforms.v1.SqlMeshIdentifier' title: sql_mesh title: sql_mesh required: - sqlMesh - properties: synqIntegrationId: type: string title: synq_integration_id description: >- Coalesce Quality integration ID maps to the created integration on the Coalesce Quality platform. title: synq_integration_id required: - synqIntegrationId - properties: trino: $ref: '#/components/schemas/synq.platforms.v1.TrinoIdentifier' title: trino title: trino required: - trino - properties: unknown: $ref: '#/components/schemas/synq.platforms.v1.UnknownDataPlatform' title: unknown title: unknown required: - unknown additionalProperties: false description: >- DataPlatformIdentifier is a unique reference to a data platform integrated with Coalesce Quality. synq.entities.v1.DataproductIdentifier: type: object properties: id: type: string format: uuid description: Dataproduct id that identifies the Dataproduct title: DataproductIdentifier required: - id additionalProperties: false synq.entities.v1.FolderRef: type: object properties: rootEntityId: type: string 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. folders: type: array items: type: string 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. title: FolderRef additionalProperties: false description: >- FolderRef is the human-friendly, structured address of a folder: the entity it hangs under (`root_entity_id`) plus the ordered folder names from that root down to the folder (`folders`). It is the stable way to name a folder across responses. Prefer it over the opaque folder entity id when you want to log, display, or reconstruct a location — the segments are the same names a user sees in the catalog, and they survive changes to the underlying id encoding. A `FolderRef` with an empty `folders` list names the root entity itself (a top-level integration or container the hierarchy hangs from). This type lives in `synq.entities.v1` (rather than a folder-specific package) so it can be shared by both the folders navigation API and the query API without an import cycle. synq.queries.v1.FolderOf: type: object properties: entityIds: type: array items: type: string 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. inputQuery: $ref: '#/components/schemas/synq.queries.v1.Query' description: >- General source: resolve the folder(s) of whatever assets this query matches (e.g. a name or type filter). Use when the assets can't be listed up front. includeAllAncestors: type: boolean 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. title: FolderOf additionalProperties: false description: > Resolves the folder(s) containing a set of assets, for use as the folder source of `InFolder` — i.e. "everything in the same folder as these assets". Name the assets either the simple way (`entity_ids`, opaque asset ids) or with a full `input_query` when they need to be computed (e.g. by name or type). Set exactly one. folder_of.exactly_one_source // set exactly one of entity_ids or input_query 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_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_SYNQ synq.entities.v1.AirflowDagIdentifier: type: object properties: integrationId: type: string description: Coalesce Quality integration_id that identifies the Airflow instance dagId: type: string description: Airflow dag_id that identifies the DAG title: AirflowDagIdentifier required: - integrationId - dagId additionalProperties: false synq.entities.v1.AirflowTaskIdentifier: type: object properties: integrationId: type: string description: Coalesce Quality integration_id that identifies the Airflow instance dagId: type: string description: Airflow dag_id that identifies the DAG taskId: type: string description: Airflow task_id that identifies the task within the DAG title: AirflowTaskIdentifier required: - integrationId - dagId - taskId additionalProperties: false synq.entities.v1.AthenaTableIdentifier: type: object properties: instance: type: string description: |- AWS account and region the Athena workgroup runs in, formatted as "." (e.g. "123456789012.eu-west-1"). Auto-derived from sts:GetCallerIdentity at integration setup time. catalog: type: string description: |- Glue Data Catalog name. Almost always "AwsDataCatalog" — the default catalog for Athena unless the customer registered a federated catalog. database: type: string description: Glue database (the namespace users typically filter on). table: type: string description: Glue table or view name. title: AthenaTableIdentifier required: - instance - catalog - database - table additionalProperties: false synq.entities.v1.BigqueryTableIdentifier: type: object properties: project: type: string description: BigQuery project dataset: type: string description: BigQuery dataset id table: type: string description: BigQuery table name title: BigqueryTableIdentifier required: - project - dataset - table additionalProperties: false synq.entities.v1.ClickhouseTableIdentifier: type: object properties: host: type: string description: Clickhouse hostname without port schema: type: string description: Clickhouse database table: type: string description: Clickhouse table title: ClickhouseTableIdentifier required: - host - schema - table additionalProperties: false synq.entities.v1.CustomIdentifier: type: object properties: id: type: string description: |- Id that identifies the custom entity The Id should be unique within the custom entity Identifier. title: CustomIdentifier required: - id additionalProperties: false synq.entities.v1.DatabricksTableIdentifier: type: object properties: workspace: type: string description: URL of Databricks workspace catalog: type: string description: Databricks catalog schema: type: string description: Databricks schema table: type: string description: Databricks table or view title: DatabricksTableIdentifier required: - workspace - catalog - schema - table additionalProperties: false synq.entities.v1.DbtCloudNodeIdentifier: type: object properties: projectId: type: string description: Your dbt Cloud project id accountId: type: string description: Your dbt Cloud account id nodeId: type: string description: Dbt node_id that identifies one of dbt DAG nodes (model, test, etc) title: DbtCloudNodeIdentifier required: - projectId - nodeId additionalProperties: false synq.entities.v1.DbtCoreNodeIdentifier: type: object properties: integrationId: type: string description: >- Opaque identifier of the dbt Core project. Usually the Coalesce Quality integration id (a UUID), but may also be the dbt project name from manifest.json when the integration is configured to identify assets by project name. Treat it as an opaque string, not a UUID. nodeId: type: string description: Dbt node_id that identifies one of dbt DAG nodes (model, test, etc) title: DbtCoreNodeIdentifier required: - integrationId - nodeId additionalProperties: false synq.entities.v1.FabricTableIdentifier: type: object properties: instance: type: string description: |- Workspace SQL analytics endpoint host, e.g. ".datawarehouse.fabric.microsoft.com". database: type: string description: Fabric warehouse / lakehouse (database). schema: type: string description: Schema within the database. table: type: string description: Table or view name. workspaceId: type: string 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. tenantId: type: string description: >- Entra (Azure AD) tenant GUID, decoded from the endpoint host in `instance`. Optional and informational, like workspace_id. title: FabricTableIdentifier required: - instance - database - schema - table additionalProperties: false description: |- Microsoft Fabric warehouse/lakehouse table identifier. Fabric is workspace-scoped with cross-database three-part [database].[schema].[table] T-SQL names. synq.entities.v1.MonitorIdentifier: type: object properties: monitoredId: $ref: '#/components/schemas/synq.entities.v1.Identifier' description: Identifier of the monitored entity monitorId: type: string description: Identifier of the monitor segment: type: string description: Optional monitor segmentation identifier nullable: true integrationId: type: string description: Coalesce Quality integration_id of the monitored identifier nullable: true deprecated: true title: MonitorIdentifier required: - monitoredId - monitorId additionalProperties: false synq.entities.v1.MssqlTableIdentifier: type: object properties: host: type: string description: Hostname of the SQL Server instance database: type: string description: SQL Server database schema: type: string description: SQL Server schema (e.g. "dbo") table: type: string description: SQL Server table or view title: MssqlTableIdentifier required: - host - database - schema - table additionalProperties: false synq.entities.v1.MysqlTableIdentifier: type: object properties: host: type: string description: Mysql hostname without port schema: type: string description: Mysql database table: type: string description: Mysql table title: MysqlTableIdentifier required: - host - schema - table additionalProperties: false synq.entities.v1.OracleTableIdentifier: type: object properties: host: type: string description: Hostname of the Oracle instance serviceName: type: string description: Oracle service name (PDB) schema: type: string description: Oracle schema (= owning user) table: type: string description: Oracle table or view title: OracleTableIdentifier required: - host - serviceName - schema - table additionalProperties: false synq.entities.v1.PostgresTableIdentifier: type: object properties: host: type: string description: Postgres hostname without port database: type: string description: Postgres database schema: type: string description: Postgres schema table: type: string description: Postgres table title: PostgresTableIdentifier required: - host - database - schema - table additionalProperties: false synq.entities.v1.RedshiftTableIdentifier: type: object properties: cluster: type: string description: Redshift cluster database: type: string description: Redshift database schema: type: string description: Redshift schema table: type: string description: Redshift table title: RedshiftTableIdentifier required: - database - schema - table additionalProperties: false synq.entities.v1.SavedViewIdentifier: type: object properties: id: type: string format: uuid description: Saved view id (client-supplied UUID) that identifies the saved view title: SavedViewIdentifier required: - id additionalProperties: false synq.entities.v1.SnowflakeTableIdentifier: type: object properties: account: type: string description: Snowflake account database: type: string description: Snowflake database schema: type: string description: Snowflake schema table: type: string description: Snowflake table title: SnowflakeTableIdentifier required: - account - database - schema - table additionalProperties: false synq.entities.v1.SqlMeshAuditIdentifier: type: object properties: integrationId: type: string format: uuid description: Coalesce Quality integration_id that identifies the dbt Core project fqn: type: string description: SQLMesh model fully qualified name auditId: type: string description: Identifier of the audit title: SqlMeshAuditIdentifier required: - integrationId - fqn - auditId additionalProperties: false synq.entities.v1.SqlMeshModelIdentifier: type: object properties: integrationId: type: string format: uuid description: Coalesce Quality integration_id that identifies the dbt Core project fqn: type: string description: SQLMesh model fully qualified name title: SqlMeshModelIdentifier required: - integrationId - fqn additionalProperties: false synq.entities.v1.SynqPathIdentifier: type: object properties: path: type: string description: >- Coalesce Quality path that identifies the Coalesce Quality entity, needs to be one of supported paths title: SynqPathIdentifier required: - path additionalProperties: false synq.entities.v1.TrinoTableIdentifier: type: object properties: host: type: string description: Hostname of the Trino instance catalog: type: string description: Trino catalog schema: type: string description: Trino schema table: type: string description: Trino table or view title: TrinoTableIdentifier required: - host - catalog - schema - table additionalProperties: false synq.entities.v1.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_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_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_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_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_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_CUSTOM_ENTITY_GENERIC - ENTITY_TYPE_CUSTOM_ENTITY_CUSTOM_TYPE_MIN - ENTITY_TYPE_CUSTOM_ENTITY_CUSTOM_TYPE_MAX synq.platforms.v1.AthenaIdentifier: type: object properties: instance: type: string description: |- AWS account and region the Athena workgroup runs in, formatted as "." (e.g. "123456789012.eu-west-1"). Auto-derived by SYNQ from sts:GetCallerIdentity at integration setup time. catalog: type: string description: |- Glue Data Catalog name. Almost always "AwsDataCatalog" — the default catalog for Athena unless the customer registered a federated catalog. title: AthenaIdentifier required: - instance - catalog additionalProperties: false synq.platforms.v1.BigqueryIdentifier: type: object properties: project: type: string description: BigQuery project title: BigqueryIdentifier required: - project additionalProperties: false synq.platforms.v1.ClickhouseIdentifier: type: object properties: host: type: string description: Clickhouse host inclusive of port schema: type: string description: Clickhouse database title: ClickhouseIdentifier required: - host - schema additionalProperties: false synq.platforms.v1.DatabricksIdentifier: type: object properties: workspace: type: string description: URL of the databricks workspace title: DatabricksIdentifier required: - workspace additionalProperties: false synq.platforms.v1.DbtCloudIdentifier: type: object properties: apiEndpoint: type: string description: API endpoint for Dbt Cloud accountId: type: string description: Account ID projectId: type: string description: Project ID title: DbtCloudIdentifier required: - apiEndpoint - accountId - projectId additionalProperties: false synq.platforms.v1.DuckDbIdentifier: type: object properties: motherduckAccount: type: string title: DuckDbIdentifier additionalProperties: false synq.platforms.v1.FabricIdentifier: type: object properties: instance: type: string description: |- Workspace SQL analytics endpoint host, e.g. ".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. workspaceId: type: string 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. tenantId: type: string 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. title: FabricIdentifier required: - instance additionalProperties: false synq.platforms.v1.MssqlIdentifier: type: object properties: host: type: string description: SQL Server host database: type: string description: Database name title: MssqlIdentifier required: - host - database additionalProperties: false synq.platforms.v1.MysqlIdentifier: type: object properties: host: type: string description: Mysql host inclusive of port title: MysqlIdentifier required: - host additionalProperties: false synq.platforms.v1.OracleIdentifier: type: object properties: host: type: string description: Oracle host serviceName: type: string description: Oracle service name (PDB) title: OracleIdentifier required: - host - serviceName additionalProperties: false synq.platforms.v1.PostgresIdentifier: type: object properties: host: type: string description: Postgres host inclusive of port database: type: string description: Postgres database title: PostgresIdentifier required: - host - database additionalProperties: false synq.platforms.v1.RedshiftIdentifier: type: object properties: cluster: type: string description: Redshift cluster database: type: string description: Redshift database title: RedshiftIdentifier required: - cluster - database additionalProperties: false synq.platforms.v1.SnowflakeIdentifier: type: object properties: account: type: string description: Snowflake account database: type: string description: Snowflake database title: SnowflakeIdentifier required: - account - database additionalProperties: false synq.platforms.v1.SqlMeshIdentifier: type: object properties: defaultDatabaseInstance: type: string description: Default database instance for SQL Mesh title: SqlMeshIdentifier required: - defaultDatabaseInstance additionalProperties: false synq.platforms.v1.TrinoIdentifier: type: object properties: coordinator: type: string title: TrinoIdentifier additionalProperties: false synq.platforms.v1.UnknownDataPlatform: type: object title: UnknownDataPlatform additionalProperties: false securitySchemes: bearerAuth: type: http scheme: bearer ````