Module: connectors

References

CommandGoverningDefinition

Re-exports CommandGoverningDefinition

DatasetLayout

Re-exports DatasetLayout

Type Aliases

SourceBinding

Ƭ SourceBinding: Object

Type declaration

Name	Type
`version`	`1`
`integration`	`IntegrationAddress`
`collection`	`string`
`scope?`	`Record`<`string`, `string`>

CommandRefs

Ƭ CommandRefs<A, Contracts>: { readonly [K in keyof A]: CommandHandle<ObjectType<A[K]>, K extends keyof Contracts ? Contracts[K] extends Object | Object ? “collection” : “record” : “record”> } Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Record`<`string`, `Fields`>
`Contracts`	{}

TransportCollections

Ƭ TransportCollections<S, R, L>: S & L extends LatestProjection<R> ? { latest: R } : {} Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`R`	extends `Fields`
`L`	`L`

HttpParameters

Ƭ HttpParameters<C>: C extends { parameters: infer P } ? P extends Fields ? ObjectType<P> : never : never Not exported: an exported type refers to it.

Type parameters

Name
`C`

IntegrationContext

Ƭ IntegrationContext<H, Setup>: Object

Type parameters

Name	Type
`H`	extends `HttpContracts` = `HttpContracts`
`Setup`	extends `Record`<`string`, `Value`> = `Record`<`string`, `string`>

Type declaration

Name	Type	Description
`setup`	`Readonly`<`Setup`>	Declared non-secret setup from the invocation’s retained connection. Retries see the same values; secrets remain in host credential custody.
`request`	<N>(`contract`: `N`, `parameters?`: `HttpParameters`<`H`[`N`]>) => `Promise`<`HttpOutcome`<`H`[`N`]>>	-

Retention

Ƭ Retention: { kind: "unknown" } | { kind: "stated" ; unit: "minutes" | "hours" | "days" ; value: number } How long a provider keeps a retained position resumable. It is not a number of days. DynamoDB’s shard iterator expires in fifteen MINUTES, and rounding that up to a day holds a recovered position two orders of magnitude past the point the provider still honours it. Kubernetes has two expiry boundaries and neither is a duration at all — etcd’s compaction revision and the apiserver’s in-memory event window — so the honest statement is unknown. Naming a number of days there would be worse than naming nothing, because it would make the engine believe it had checked something. The unit is the provider’s own word. unknown is the absence of a promise and never a promise that has run out: a channel whose retention is unknown never treats a retained position as fresh, so every resume needs the prefix check and a resume the check cannot decide stays unproved.

ResumePrefix

Ƭ ResumePrefix: { kind: "none" } | { kind: "served_floor" ; floor: Selector } | { kind: "restart" ; field: readonly string[] ; value: string ; restart_status?: number } | { kind: "ancestry" ; descends: Selector } Not exported: an exported type refers to it.

SourceProtocol

Ƭ SourceProtocol: { kind: "stream_latest" ; policy: { key: string[] ; order_by: string[] ; publish_every: SyncEvery } } | { kind: "snapshot_and_log" } | { kind: "change_feed" ; version?: { kind: "opaque" } ; position: { domain: string ; encoding: "uint64_decimal" | "int64_decimal" } ; checkpoint: { initial: string ; continuity: "complete_prefix" ; retention: Retention } ; records: "full_or_delete" ; atomic_group: "one_change" } | { kind: "record_observation" ; version: { kind: "opaque" } | { kind: "none" } ; coverage: { kind: "enumeration" } | { kind: "query_result" ; max_rows: number } | { kind: "incremental_snapshot" ; max_rows: number } | { kind: "filtered" ; completeness: "stated" | "none" } | { kind: "none" } ; resume: { kind: "opaque_cursor" } | { kind: "none" } } What an acquisition actually proves. Records with a done flag and a a resume cursor are not a change feed; declaring one would claim ordering and completeness the provider never established.

CoupledResult

Ƭ CoupledResult<S>: wire.CoupledResult<{ [K in keyof S]: RecordObservation<ObjectType<S[K]>>[] }, keyof S & string> What one coupled acquisition attempt claims, as a candidate only. The envelope is generated; this states the two narrowings that are facts about the declaration rather than about the wire, exactly as ProtocolInput and ProtocolResult do below: records is a mapped type over the author’s own collection schemas, and every collection named by an unresolved key or a file request is one of the author’s own collections.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>

TimestampWindowDiscovery

Ƭ TimestampWindowDiscovery: Object Frozen host-time windows for ServiceNow discovery. Completion advances only after the final accepted page. Full rediscovery and point verification still run independently; timestamps establish neither history nor coverage.

Type declaration

Name	Type
`overlap_seconds`	`number`
`settle_seconds`	`number`
`full_every`	`SyncEvery`

CouplingDefinition

Ƭ CouplingDefinition<S, H, Setup>: Object One acquisition over a whole group of collections: the collections it owns, the one interval the group is scheduled on, and the one reader.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`H`	extends `HttpContracts` = `HttpContracts`
`Setup`	extends `Record`<`string`, `Value`> = `Record`<`string`, `string`>

Type declaration

Name	Type	Description
`collections`	readonly keyof `S` & `string`[]	-
`reconcile?`	{ `absent`: `404` \| `410` }	Recheck previously published keys omitted by the live traversal. A retained singleton response with this status withdraws every corresponding member atomically. Other failures stay unresolved. No coverage is claimed.
`reconcile.absent`	`404` \| `410`	-
`every`	`SyncEvery`	-
`read`	(`ctx`: `IntegrationContext`<`H`, `Setup`>, `input`: `CoupledInput`) => `Promise`<`CoupledResult`<`S`>>	-

ProtocolInput

Ƭ ProtocolInput<P>: [P] extends [{ kind: "record_observation" }] ? EnumerationInput | IncrementalInput | SweepInput : [P] extends [{ kind: "change_feed" }] ? FeedInput : SyncInput Not exported: an exported type refers to it.

Type parameters

Name	Type
`P`	extends `SourceProtocol`

ProtocolResult

Ƭ ProtocolResult<P, T>: [P] extends [{ kind: "record_observation" }] ? RecordResult<T> : [P] extends [{ kind: "change_feed" }] ? ChangeFeedResult<T> : ChangeFeedResult<T> | RecordResult<T> Not exported: an exported type refers to it.

Type parameters

Name	Type
`P`	extends `SourceProtocol`
`T`	`T`

DeliveryField

Ƭ DeliveryField: { kind: "header" ; name: string } | { kind: "body" ; path: WirePath } Not exported: an exported type refers to it.

IngressAuthentication

Ƭ IngressAuthentication: { kind: "shared_token" ; field: DeliveryField } | { kind: "configured_token" ; field: DeliveryField } | { kind: "timestamped_hmac_sha256" ; header: string ; timestamp: { kind: "element" ; name: string } | { kind: "header" ; name: string } ; signature_element?: string ; elements?: { separator: string ; delimiter: string } ; payload_prefix?: { kind: "literal" ; value: string } | { kind: "header" ; name: string ; separator: string } ; separator: string ; digest: "hex" | "base64" ; tolerance_seconds: number ; timestamp_unit?: "seconds" | "milliseconds" ; timestamp_format?: "unix" | "rfc3339" } | { kind: "timestamped_ed25519" ; header: string ; timestamp_header: string ; tolerance_seconds: number } | { kind: "hmac_sha256" ; header: string ; signature_element?: string ; digest: "hex" | "base64" ; rotation_headers?: readonly string[] } | { kind: "hmac_sha1" ; header: string ; digest: "hex" | "base64" } | { kind: "es256_jwt" ; header: string ; jwks_path: string ; body_digest_claim: string ; digest: "hex" | "base64" ; tolerance_seconds: number ; key_request?: { key_id_field: string ; key_path: WirePath ; expired_path?: WirePath } } Not exported: an exported type refers to it.

ListenerIngress

Ƭ ListenerIngress: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`delivery`	`DeliveryField`
`channel?`	`DeliveryField`
`resource?`	`DeliveryField`
`resource_handle?`	`DeliveryField`
`authentication`	`IngressAuthentication`
`signing_key?`	{ `kind`: `"literal"` } \| { `kind`: `"base64"` ; `prefix?`: `string` }
`body`	`Exclude`<`BodyContract`, { `kind`: `"text"` }>
`max_body_bytes`	`number`
`proves`	`"refresh_hint"` \| `"occurrence"`
`position?`	`DeliveryField`
`refreshRecord?`	`DeliveryField`
`challenge?`	{ `header`: `string` ; `field`: `string` }
`challenge.header`	`string`
`challenge.field`	`string`

OccurrenceHandler

Ƭ OccurrenceHandler: Object How change hints reach the engine for one collection, and the whole of what a listener declares. The variant is the transport class and it carries what that transport needs. push has an ingress endpoint because the provider delivers to one; pull has none, because nothing is delivered to it. Neither is an optional field a declaration could leave empty. A hint requests acquisition. A business occurrence retains its exact body and stable identity for the declared operation.

Type declaration

Name	Type
`operation`	`string` \| `OperationReference`<`any`, { `source`: `string` ; `occurrence`: `string` ; `eventType`: `string` ; `digest`: `string` }, `any`>
`event_type_path`	readonly `string`[]
`admitted_types`	readonly `string`[]
`ignored_types`	readonly `string`[]

ListenerProtocol

Ƭ ListenerProtocol: { kind: "queue" ; provider: "sqs" ; visibility_seconds: number ; wait_seconds: number ; poll_interval_ms: number ; proves: "refresh_hint" | "occurrence" ; handler?: OccurrenceHandler } | { kind: "socket" ; open: string ; address: Selector ; envelope: readonly string[] ; frame_kind: readonly string[] ; disconnect: string ; acknowledge: string ; max_frame_bytes: number ; proves: "refresh_hint" } | { kind: "push" ; handler?: OccurrenceHandler ; telemetry?: EventAcquisitionTransport ; ingress: ListenerIngress ; archive?: true ; subscription?: { channel: { resource: readonly string[] ; proof: { channel_id: Selector ; resource_id: Selector ; resource_uri: Selector ; expiration: Selector } ; matching: { tolerated_query?: readonly string[] ; lifetime_ms: number ; renewal_margin_ms: number } } ; watch: string ; stop: string } } | { kind: "pull" ; poll: string ; interval_ms: number ; min_interval_ms: number ; max_interval_ms: number ; continuation: { kind: "validator" ; request_header: string ; response_header: string ; interval_header?: string ; quiet_status: number } | { kind: "cursor" ; parameter: string ; resume: ResumePrefix ; retention: Retention ; link?: { header: string ; relation: string } } ; position: { items?: readonly string[] ; id: readonly string[] ; order: "decimal" | "opaque" | "opaque_ascending" } ; keys?: { list: string ; items?: readonly string[] ; id?: readonly string[] ; parameter: string ; partition: readonly string[] } }

CollectionShape

Ƭ CollectionShape<S, P>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Fields`
`P`	extends `SourceProtocol`

Type declaration

Name	Type
`schema`	`S`
`protocol`	`P`
`key_reuse?`	`"never"`
`freshness?`	`SyncEvery`
`listener?`	`ListenerProtocol`
`orderingAlias?`	{ `path`: `string`[] }
`orderingAlias.path`	`string`[]
`release?`	`string`
`reconcile?`	{ `every`: `SyncEvery` ; `absent?`: `number` ; `absentRecord?`: `string`[] ; `absentWhen?`: { `path`: `string`[] ; `value`: `Exclude`<`ScalarValue`, { `type`: `"null"` \| `"missing"` }> } }
`reconcile.every`	`SyncEvery`
`reconcile.absent?`	`number`
`reconcile.absentRecord?`	`string`[]
`reconcile.absentWhen?`	{ `path`: `string`[] ; `value`: `Exclude`<`ScalarValue`, { `type`: `"null"` \| `"missing"` }> }
`reconcile.absentWhen.path`	`string`[]
`reconcile.absentWhen.value`	`Exclude`<`ScalarValue`, { `type`: `"null"` \| `"missing"` }>

CollectionDefinition

Ƭ CollectionDefinition<S, H, P, Setup>: CollectionShape<S, P> & { deliveryOnly: true ; sync?: never ; freshness?: never ; listener?: never ; reconcile?: never ; release?: never ; orderingAlias?: never } | { deliveryOnly?: never ; sync: { every: SyncEvery ; discovery?: TimestampWindowDiscovery ; read: (ctx: IntegrationContext<H, Setup>, input: ProtocolInput<P>) => Promise<ProtocolResult<P, ObjectType<S>>> } } A collection acquired on its own: it declares its own interval and its own reader.

Type parameters

Name	Type
`S`	extends `Fields`
`H`	extends `HttpContracts` = `HttpContracts`
`P`	extends `SourceProtocol` = `Extract`<`SourceProtocol`, { `kind`: `"change_feed"` }>
`Setup`	extends `Record`<`string`, `Value`> = `Record`<`string`, `string`>

CoupledCollectionDefinition

Ƭ CoupledCollectionDefinition<S, P>: CollectionShape<S, P> & { sync?: never } A collection of a coupled group. One acquisition walks the whole group, so the group’s coupling owns the interval and the read and the collection declares neither: a per-collection sync here would name a schedule nothing runs and a reader nothing calls.

Type parameters

Name	Type
`S`	extends `Fields`
`P`	extends `SourceProtocol` = `SourceProtocol`

CommandInput

Ƭ CommandInput<A>: Object What a RECORD-TARGETED command’s handlers receive.

Type parameters

Name	Type
`A`	extends `Fields`

Type declaration

Name	Type	Description
`target`	{ `native_key`: `string` ; `native_version?`: `string` }	`native_version` is present exactly when the command declares a conditional precondition. An `unconditional` command omits the key entirely; the native side never substitutes an empty string for it.
`target.native_key`	`string`	-
`target.native_version?`	`string`	-
`args`	`ObjectType`<`A`>	-
`operation_id`	`string`	-
`provider_work_key?`	`string`	Native identities retained from an accepted asynchronous send and its sole task. Available only during reconciliation.
`provider_task_key?`	`string`	-
`expires_at?`	`string`	Present only when the destination enforces request expiry. A locally bounded dispatch does not manufacture a provider deadline.

CreateCommandInput

Ƭ CreateCommandInput<A>: Object What a CREATE’s handlers receive. There is no target at all, and that absence is the declaration: the send addresses the collection, so there is no record to name and operation_id is what the request carries in its place. created is the provider’s own key for the record this operation made, present on the reconcile once the destination has named it.

Type parameters

Name	Type
`A`	extends `Fields`

Type declaration

Name	Type
`args`	`ObjectType`<`A`>
`operation_id`	`string`
`created?`	`string`
`provider_work_key?`	`string`
`provider_task_key?`	`string`
`expires_at?`	`string`

CommandResult

Ƭ CommandResult<S>: { evidence: ResponseEvidence } & { outcome: "confirmed" ; observations?: { [K in keyof S]?: Observation<ObjectType<S[K]>>[] } ; readback?: { key: string ; version: string ; value: ObjectType<S[keyof S]> } } | { outcome: "rejected" ; reason: string } | { outcome: "refused" } | { outcome: "pending" | "unknown" } | { outcome: "counted" } | { outcome: "withdrawn" } Candidate interpretation only. Native retained-response evidence must admit completion, identity, membership and source progress independently.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>

CommandCondition

Ƭ CommandCondition: { kind: "target_version" ; from: { kind: "record_observation_position" } | { kind: "record_version" } } | { kind: "unconditional" } | { kind: "field_ownership" } | { kind: "target_state" } Exact native provenance for the provider’s conditional version. An ordered feed position and an opaque record token are not interchangeable. unconditional states that the destination enforces no compare-and-set on this endpoint, so the request carries no provider conditional token at all. It is the ABSENCE of a precondition, never an empty or fabricated one, and it promises nothing about writers acting directly in the provider.

CommandStates

Ƭ CommandStates<A>: Object The change a record-targeted command’s send REQUESTS of its target record, field by field: each key is a field of the target collection’s schema, and each value is the path into this command’s arguments whose value the request asks that field to take. Every path names REQUIRED arguments, and the argument’s type must be one the field admits. On a branch, where nothing is delivered, a held call is shown as this change with assumed provenance. Standing maintenance uses the same declaration to define desired values on live. Neither use supplies evidence that the destination applied anything, and fields the provider computes — assigned identifiers, totals — are not stated and stay as last observed. A create cannot state a change: its record’s key is the provider’s to assign.

Type parameters

Name	Type
`A`	extends `Fields`

Index signature

▪ [field: string]: readonly [keyof A & string, …string[]]

CommandDefinition

Ƭ CommandDefinition<A, S, H, Setup>: CommandShape<A, S> & { scope: "collection" ; condition: { kind: "unconditional" } ; creates?: never ; states?: never ; writes?: never ; group?: never ; send: (ctx: IntegrationContext<H, Setup>, input: CreateCommandInput<A>) => Promise<CommandResult<S>> } & { delivery: { kind: "at_least_once" ; max_delivery_hours: number } ; reconcile?: never } | { delivery: Extract<CommandShape<A, S>["delivery"], { kind: "single_attempt" }> ; reconcile: (ctx: IntegrationContext<H, Setup>, input: Omit<CreateCommandInput<A>, "expires_at">) => Promise<CommandResult<S>> } | CommandShape<A, S> & { scope?: never ; creates?: undefined ; states?: CommandStates<A> ; writes?: readonly string[] ; send: (ctx: IntegrationContext<H, Setup>, input: CommandInput<A>) => Promise<CommandResult<S>> ; reconcile?: (ctx: IntegrationContext<H, Setup>, input: Omit<CommandInput<A>, "expires_at">) => Promise<CommandResult<S>> } | CommandShape<A, S> & { scope?: never ; creates: "deduplicated" | "stored" | "unattributed" ; states?: undefined ; writes?: undefined ; send: (ctx: IntegrationContext<H, Setup>, input: CreateCommandInput<A>) => Promise<CommandResult<S>> ; reconcile: (ctx: IntegrationContext<H, Setup>, input: Omit<CreateCommandInput<A>, "expires_at">) => Promise<CommandResult<S>> } | CommandShape<A, S> & { scope?: never ; creates: "stored_from_record" ; states?: undefined ; writes?: undefined ; group?: undefined ; send: (ctx: IntegrationContext<H, Setup>, input: CommandInput<A> & CreateCommandInput<A>) => Promise<CommandResult<S>> ; reconcile: (ctx: IntegrationContext<H, Setup>, input: Omit<CommandInput<A> & CreateCommandInput<A>, "expires_at">) => Promise<CommandResult<S>> } One command. Record commands receive the existing target’s private key; collection creates receive the operation identity without a target. A child creation receives both its existing parent’s key and the operation identity. Any proved child key is retained separately and available during reconciliation.

Type parameters

Name	Type
`A`	extends `Fields`
`S`	extends `Record`<`string`, `Fields`>
`H`	extends `HttpContracts` = `HttpContracts`
`Setup`	extends `Record`<`string`, `Value`> = `Record`<`string`, `string`>

TransportCommandDefinition

Ƭ TransportCommandDefinition<A, S>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Fields`
`S`	extends `Record`<`string`, `Fields`>

Type declaration

Name	Type
`target`	keyof `S` & `string`
`args`	`A`
`charges?`	readonly `AllowanceCharge`<`AllowanceAmountArgument`<`ObjectType`<`A`>>>[]
`delivery`	`CommandShape`<`A`, `S`>[`"delivery"`]
`condition`	`CommandCondition`
`creates?`	`"stored"` \| `"unattributed"`
`group?`	`CommandShape`<`A`, `S`>[`"group"`]
`states?`	`CommandStates`<`A`>
`writes?`	readonly `string`[]
`governingRule`	`CommandGoverningDefinition`

SourceHandle

Ƭ SourceHandle<S, Scope>: Object

Type parameters

Name	Type
`S`	extends `Fields` = `Fields`
`Scope`	extends `Record`<`string`, `Value`> = {}

Type declaration

Name	Type	Description
`schema`	`S`	-
`[sourceExport]`	() => `SourceBinding`	Only a compiler-bound integration supplies this capability.
`__sourceType?`	`ObjectType`<`S`>	Phantom shape used to check the destination table’s validator.
`__scopeType?`	`Scope`	-
`resourceValidator`	`VObject`	-
`withScope`	<ScopeFields>(`fields`: `ScopeFields`) => `SourceHandle`<`S` & `ScopeFields`, `ObjectType`<`ScopeFields`>>	Add immutable application references supplied by source installation. The source continues to own the complete effective row contract.

ConnectionBudget

Ƭ ConnectionBudget: { capacity: number ; restorePerSecond: number ; restorePerMinute?: undefined ; perMinute?: undefined } | { capacity: number ; restorePerMinute: number ; restorePerSecond?: undefined ; perMinute?: undefined } | { perMinute: number ; capacity?: undefined ; restorePerSecond?: undefined ; restorePerMinute?: undefined } & { requestCost?: number ; stated?: { available: Selector ; capacity?: Selector ; restorePerSecond?: Selector } } What one connection may spend, and where the provider’s answers state it. The budget belongs to the connection rather than to a collection: the provider counts it against the credential, so every collection, listener and command that speaks through one connection shares one bucket. Declare it in whichever form the provider publishes — a cost bucket with a restore rate, or a count per minute — and the engine keeps one quantity either way. stated names where an answer carries the provider’s own figure. A stated availability can only lower what the engine believes it has, because the engine counts its own requests and the provider counts everybody’s; a stated ceiling or rate replaces the declared one, because those are the provider’s contract rather than a measurement.

BackoffRepresentation

Ƭ BackoffRepresentation: "secondsFromResponse" | "epochSeconds" | "epochMillis" | "httpDate" | "retryAfter" How a stated backoff value is spelled.

secondsFromResponse is a duration from the answer, in seconds. It admits RFC 9110 delta-seconds (Retry-After: 120) and a fractional seconds-remaining (x-ratelimit-reset-after: 0.529) alike: those are one quantity written two ways, and a fraction is always rounded up so a wait never comes out shorter than the one asked for.
epochSeconds and epochMillis are an absolute instant. The two cannot be told apart from the value, so the declaration names the unit.
httpDate is an absolute instant as an RFC 9110 HTTP-date. The two obsolete date forms are not read.
retryAfter is the Retry-After header itself, which RFC 9110 lets a provider spell either way in the same header; the form is decided by the value rather than by the declaration.

ConnectionBackoff

Ƭ ConnectionBackoff: Object When this provider will accept another request, and where its answers say so. It belongs to the connection rather than to a collection or a command, because a provider throttles the credential. Declare the statuses this provider states a wait on, where the statement is, and the longest wait this integration will honour on its own; a provider asking for longer holds the connection for an operator instead of sleeping for it. Every declared signal is read and the LATEST instant any of them names is the one honoured: two fields stating one quantity can disagree, and waiting longer is the only safe direction. IT NEVER AUTHORIZES REPEATING AN OPERATION. This says when the provider will accept another request. Whether a particular external command may be sent again is decided by that command’s own delivery contract from its retained operation identity, and nothing declared here reaches that decision.

Type declaration

Name	Type	Description
`statuses`	readonly `number`[]	The error statuses this provider states a wait on. `429` is the ordinary one; declare `403` as well where this provider signals an exhausted quota that way. It is not a failure classifier — what kind of failure a status is stays with the response contract’s own `failures`.
`signals`	`ReadonlyArray`<{ `at`: `Selector` ; `is`: `BackoffRepresentation` }>	Where the statement is. A header name is matched without regard to case and must be declared in lower case.
`maxWaitSeconds`	`number`	The longest wait this integration honours without an operator, in seconds. At most one day.

TransportIntegrationDefinition

Ƭ TransportIntegrationDefinition<S, H, A, R, L, T, C>: Object Define source collections, sync routines and external command contracts. Compiler addresses are references, never capabilities or trusted evidence.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`> = {}
`H`	extends `HttpContracts` = {}
`A`	extends `Record`<`string`, `Fields`> = {}
`R`	extends `Fields` = {}
`L`	extends `LatestProjection`<`R`> \| `undefined` = `undefined`
`T`	extends `Record`<`string`, `unknown`> = {}
`C`	extends `Fields` = {}

Type declaration

Name	Type	Description
`label?`	`string`	-
`accountIdentity?`	`AccountIdentity`	-
`terms?`	`Fields`	Typed non-secret values configured separately for each installed source.
`transport`	`AcquisitionTransport` \| `KafkaTransport` \| `EventBrokerTransport`	-
`identify?`	`never`	-
`coupling?`	`never`	-
`setup?`	`C`	Non-secret values of one native connection, using ordinary Bijection validators.
`setupFields?`	`SetupDeclaration`	Presentation and supplier policy for string setup fields.
`budget?`	`never`	-
`backoff?`	`never`	-
`archive?`	`true`	Keep every acquired occurrence, original bytes included, in the source’s raw archive dataset `<export>_raw`.
`record?`	`RecordDefinition`<`R`>	What one event means, declared once for every decoded output.
`history?`	`true` \| `EventHistory`<`R`>	The typed event history: one Iceberg table, dataset `<export>`, or `<export>_v<n>` for a later `version`.
`latest?`	`L`	The latest row per key, bound with `defineSyncedTable({ source: source.latest })`.
`series?`	`NativeSeriesOutput`<`R`>	Accepted observations in a local native series table.
`requests?`	`H`	-
`discover?`	(`ctx`: `IntegrationContext`<`H`, `ObjectType`<`C`>>, `input`: { `resume`: `string` \| `null` ; `next_page_reference`: `ResponseEvidence` \| `null` }) => `Promise`<{ `resources`: { `id`: `string` ; `label`: `string` \| `null` }[] ; `next_page`: `string` \| `null` ; `evidence`: `ResponseEvidence` }>	-
`collections?`	{ [K in keyof S]: Object }	-
`commands?`	{ [K in keyof A]: TransportCommandDefinition<A[K], TransportCollections<S, R, L>> } & `T`	-
`every?`	`SyncEvery`	SQL sources without a cadence are available for pinned inspection only. They do not schedule or admit acquisition.

Integration

Ƭ Integration<S, H, A, R, L, T, C>: { commands: CommandRefs<A, T> } & { readonly [K in keyof S]: SourceHandle<S[K]> } & L extends LatestProjection<R> ? { latest: SourceHandle<R> } : {} & keyof R extends never ? {} : { stream: StreamRef<R> } An analyzed integration’s typed source and command handles.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`> = {}
`H`	extends `HttpContracts` = {}
`A`	extends `Record`<`string`, `Fields`> = {}
`R`	extends `Fields` = {}
`L`	extends `LatestProjection`<`R`> \| `undefined` = `undefined`
`T`	extends `Record`<`string`, `unknown`> = {}
`C`	extends `Fields` = {}

CallbackIntegrationDefinition

Ƭ CallbackIntegrationDefinition<S, A, H, T, C>: { label?: string ; accountIdentity?: AccountIdentity ; terms?: Fields ; transport?: never ; record?: never ; archive?: never ; history?: never ; latest?: never ; series?: never ; requests?: H ; setup?: C ; setupFields?: SetupDeclaration ; budget?: ConnectionBudget ; backoff?: ConnectionBackoff ; discover?: (ctx: IntegrationContext<H, ObjectType<C>>, input: { resume: string | null ; next_page_reference: ResponseEvidence | null }) => Promise<{ resources: { id: string ; label: string | null }[] ; next_page: string | null ; evidence: ResponseEvidence }> ; identify: (ctx: IntegrationContext<H, ObjectType<C>>) => Promise<{ account_id?: string ; incarnation?: string ; evidence: ResponseEvidence }> ; commands: { [K in keyof A]: CommandDefinition<A[K], S, H, ObjectType<C>> } & T } & { coupling: CouplingDefinition<S, H, ObjectType<C>> ; collections: { [K in keyof S]: CoupledCollectionDefinition<S[K], SourceProtocol> } } | { coupling?: undefined ; collections: { [K in keyof S]: CollectionDefinition<S[K], H, SourceProtocol, ObjectType<C>> } } Source collections and commands acquired through retained HTTP callbacks.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`A`	extends `Record`<`string`, `Fields`>
`H`	extends `Record`<`string`, `HttpContract` & { `browser?`: `never` }> = {}
`T`	extends `Record`<`string`, `unknown`> = {}
`C`	extends `Fields` = {}

AccountIdentityDefinition

Ƭ AccountIdentityDefinition: Object A connection that establishes a principal without importing resources.

Type declaration

Name	Type
`label?`	`string`
`accountIdentity`	`AccountIdentity`
`setup?`	`SetupDeclaration`

HttpTelemetryDefinition

Ƭ HttpTelemetryDefinition<R, H, C>: Object Authenticated HTTP telemetry retains the existing HTTP identity and listener owners.

Type parameters

Name	Type
`R`	extends `Fields`
`H`	extends `Record`<`string`, `HttpContract` & { `browser?`: `never` }>
`C`	extends `Fields`

Type declaration

Name	Type
`label?`	`string`
`accountIdentity?`	`AccountIdentity`
`setup?`	`C`
`setupFields?`	`SetupDeclaration`
`terms?`	`Fields`
`budget?`	`ConnectionBudget`
`backoff?`	`ConnectionBackoff`
`requests`	`H`
`identify`	`CallbackIntegrationDefinition`<{}, {}, `H`, {}, `C`>[`"identify"`]
`ingress`	`ListenerIngress`
`record`	`RecordDefinition`<`R`> & { `encoding`: `"json"` }
`archive?`	`true`
`history?`	`true` \| `EventHistory`<`R`>
`series?`	`NativeSeriesOutput`<`R`>
`latest`	`LatestProjection`<`R`>

RequestValue

Ƭ RequestValue<T>: T | HttpValue<T> | T extends infer U[] ? RequestValue<U>[] : T extends object ? { [K in keyof T]: RequestValue<T[K]> } : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

Options

Ƭ Options: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`readOnly`	`boolean`
`timeoutMs?`	`number`
`metadata?`	readonly `string`[]

MessageFields

Ƭ MessageFields<T>: { [K in keyof T]-?: Validator<Exclude<T[K], undefined>, undefined extends T[K] ? “optional” : “required”, any> } Not exported: an exported type refers to it.

Type parameters

Name
`T`

GrpcMethod

Ƭ GrpcMethod<I, O>: Object

Type parameters

Name
`I`
`O`

Type declaration

Name	Type
`method`	`string`
`schema`	`GrpcSchema`
`request`	(`input`: `RequestValue`<`I`>, `options`: `Options`) => `ReturnType`<typeof `http.post`>
`response`	(`options`: `Options`) => `GrpcResponse`<`O`>
`contract`	(`input`: `HttpTemplate`, `options`: `Options` & `Pick`<`HttpContract`, `"handler"` \| `"evidence"`>) => `HttpContract`
`interpret`	<T>(`handler`: (`reply`: `GrpcReply`<`O`>, `evidence`: `string`) => `T`) => (`response`: { `body`: `unknown` ; `evidence`: `string` ; `unresolved?`: `boolean` }) => `T` \| { `outcome`: `"unknown"` ; `evidence`: `string` }

HttpValue

Ƭ HttpValue<T>: Object A typed host-bound value. JavaScript coercion and computation are refused.

Type parameters

Name
`T`

Type declaration

Name	Type
`[expression]`	`HttpTemplate`
`_type?`	`T`

Creation

Ƭ Creation: "deduplicated" | "stored" | "unattributed" | "stored_from_record" | undefined Not exported: an exported type refers to it.

InputFor

Ƭ InputFor<A, C>: C extends undefined ? CommandInput<A> : C extends "stored_from_record" ? CommandInput<A> & CreateCommandInput<A> : CreateCommandInput<A> Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Fields`
`C`	extends `Creation`

RequestInputs

Ƭ RequestInputs<A, C>: { args: { readonly [K in keyof A]: HttpInput<A[K][“type”]> } ; operationId: HttpValue<string> } & C extends undefined | "stored_from_record" ? { target: { key: HttpValue<string> ; version: HttpValue<string> ; parts: ReadonlyArray<HttpValue<string>> } } : {} Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Fields`
`C`	extends `Creation`

Node

Ƭ Node: string | number | boolean | bigint | ArrayBuffer | null | HttpValue<unknown> | readonly Node[] | { [key: string]: Node; } Not exported: an exported type refers to it.

RequestShape

Ƭ RequestShape: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`path`	readonly (`string` \| `HttpValue`<`string`>)[]
`query?`	`Record`<`string`, `Node`>
`headers?`	`Record`<`string`, `Node`>
`body?`	`Node`
`request_schema?`	`HttpContract`[`"request_schema"`]
`grpc?`	`HttpContract`[`"grpc"`]
`body_encoding?`	`HttpContract`[`"body_encoding"`]

RequestBuilder

Ƭ RequestBuilder: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`method`	`HttpContract`[`"method"`]
`shape`	`RequestShape`

Exchange

Ƭ Exchange<A, C, Response, Result>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Fields`
`C`	extends `Creation`
`Response`	extends `HttpContract`[`"response"`]
`Result`	extends `CommandResult`<`any`>

Type declaration

Name	Type
`request`	`RequestBuilder` \| (`inputs`: `RequestInputs`<`A`, `C`>) => `RequestBuilder`
`response`	`Response`
`evidence`	`HttpContract`[`"evidence"`]
`interpret`	(`response`: `HttpOutcome`<{ `response`: `Response` }>) => `Promise`<`Result`> \| `Result`
`browser?`	`BrowserImplementation`<`InputFor`<`A`, `C`>>

CommandShape

Ƭ CommandShape<A, Target, C>: C extends undefined ? Extract<CommandDefinition<A, Record<Target, Fields>, any, any>, { creates?: undefined ; scope?: undefined }> : C extends "stored_from_record" ? Extract<CommandDefinition<A, Record<Target, Fields>, any, any>, { creates: "stored_from_record" }> : Extract<CommandDefinition<A, Record<Target, Fields>, any, any>, { creates: "deduplicated" | "stored" | "unattributed" }> & { creates: C } & { target: Target } Not exported: an exported type refers to it.

Type parameters

Name	Type
`A`	extends `Fields`
`Target`	extends `string`
`C`	extends `Creation`

WirePath

Ƭ WirePath: readonly string[]

HttpArgumentReference

Ƭ HttpArgumentReference: Object A retained command argument, addressed by its own field path.

Type declaration

Name	Type
`input`	`"argument"`
`path?`	`WirePath`

HttpInputReference

Ƭ HttpInputReference: { input: "setup" ; path: readonly [string] } | { input: "checkpoint" | "resume" | "operation_id" | "expires_at" | "target_version" } | { input: "target_key" ; path?: WirePath } | { input: "created_key" } | { input: "provider_work_key" } | { input: "provider_task_key" } | HttpArgumentReference | { input: "parameter" ; path?: WirePath }

HttpInput

Ƭ HttpInput: { kind: "input" } & HttpInputReference

HttpTemplate

Ƭ HttpTemplate: { kind: "key_component" ; subject: HttpInputReference ; index: number } | { kind: "json_string" ; value: HttpTemplate } | { kind: "host" ; value: "workload_context" | "workload_context_ref" | "listener_channel_id" | "listener_callback_url" | "listener_expiration" | "listener_resource_id" | "listener_channel_token" } | { kind: "resume_path" ; prefix: string } | { kind: "resource_segment" ; subject: HttpInputReference ; prefix: readonly (HttpInput | { kind: "literal" ; value: string })[] ; suffix?: string } | { kind: "literal" ; value: JSONValue } | HttpInput | { kind: "object" ; fields: Record<string, HttpTemplate> } | { kind: "array" ; items: readonly HttpTemplate[] } | { kind: "concat" ; parts: readonly ({ kind: "literal" ; value: string } | HttpInput)[] }

Selector

Ƭ Selector: { kind: "header" ; name: string } | { kind: "body" ; path?: WirePath } Where one piece of evidence is read in a retained response. A provider’s conditional token is often a header, so selection cannot assume a body.

DocumentCodec

VdaLayout

Ƭ VdaLayout: Object The layouts a vda document reads. records gives each record type’s fields after its five-character type and version, in order, with their widths; a prefix of the record suffices. Exactly one declared type ends in 11 (the header) and one in 19 (the trailer), of one family. counts maps a trailer field to the record type it counts; key names header fields the host renders as each transmission’s transmission identity.

Type declaration

Name	Type
`records`	`Record`<`string`, readonly { `name`: `string` ; `length`: `number` }[]>
`counts?`	`Record`<`string`, `string`>
`key?`	readonly `string`[]

CopybookField

Ƭ CopybookField: { name: string ; type: "text" ; length: number ; occurs?: number } | { name: string ; type: "filler" ; length: number } | { name: string ; type: "zoned" | "packed" | "binary" ; digits: number ; scale?: number ; signed?: boolean ; occurs?: number } One elementary item of a COBOL copybook, in record order. Text and filler state their bytes (PIC X(n)); numeric items state their digits, implied decimal places (V99) and whether the picture is signed (S). zoned is usage DISPLAY, packed is COMP-3, binary is COMP, COMP-4, COMP-5 or BINARY. occurs repeats the item in place. Hyphens in COBOL names become underscores.

CopybookLayout

Ƭ CopybookLayout: Object A copybook’s record layout. encoding is the code page of text bytes (IBM 037, 1140, 500 or 273 EBCDIC, or ASCII); framing is how records are delimited: back to back (fixed), each behind a four-byte record descriptor word (rdw), or one per line (lines, ASCII text and zoned items only). key names the items whose values identify a record; the host renders them as each record’s record (one value as itself, several as a JSON array), and without a key a record is named by its position. A key item the host could not read names the record by the original’s digest and position. REDEFINES and OCCURS DEPENDING ON are not expressible.

Type declaration

Name	Type
`encoding`	`"cp037"` \| `"cp1140"` \| `"cp500"` \| `"cp273"` \| `"ascii"`
`framing`	`"fixed"` \| `"rdw"` \| `"lines"`
`fields`	readonly `CopybookField`[]
`key?`	readonly `string`[]

UnwrapStep

Ƭ UnwrapStep: { kind: "gzip" } | { kind: "base64" } | { kind: "charset" ; from: "windows_1252" | "iso_8859_15" | "iso_8859_2" | "shift_jis" | "utf16le" | "utf16be" } Not exported: an exported type refers to it.

DocumentDeclaration

Ƭ DocumentDeclaration: { codec: "xml" ; validator: Validator<any, any, any> ; markup?: { attributes: string ; text: string } ; unwrap?: readonly UnwrapStep[] } | { codec: "idoc" ; validator: Validator<any, any, any> ; segments: Record<string, readonly { name: string ; length: number }[]> ; unwrap?: readonly UnwrapStep[] } | { codec: "copybook" ; validator: Validator<any, any, any> ; copybook: CopybookLayout ; unwrap?: readonly UnwrapStep[] } | { codec: "vda" ; validator: Validator<any, any, any> ; vda: VdaLayout ; unwrap?: readonly UnwrapStep[] } | { codec: Exclude<DocumentCodec, "xml" | "idoc" | "copybook" | "vda"> ; validator: Validator<any, any, any> ; unwrap?: readonly UnwrapStep[] } A document the host decodes: its codec, the validator the decoded value must satisfy, and the codec’s options. At most four unwrap steps; a copybook or vda document admits no charset step, because its layout counts bytes.

BodyContract

Ƭ BodyContract: { kind: "grpc" ; exchange: GrpcExchange ; _message?: unknown } | { kind: "text" } | { kind: "none" } | { kind: "json" ; validator: Validator<any, any, any> } | { kind: "json_schema" ; schema: HttpWireSchema ; validator: Validator<any, any, any> } | { kind: "document" } & DocumentDeclaration | { kind: "positional" ; schema: WirePath ; name: WirePath ; column_type: WirePath ; rows: WirePath ; cells: WirePath ; value: WirePath ; columns: Record<string, string> ; validator: Validator<any, any, any> } | { kind: "json_fields" ; fields: readonly string[] ; optional_fields?: readonly string[] ; paths?: Record<string, readonly string[]> ; decimal_fields?: readonly string[] } | { kind: "json_batch" ; selection: { items: WirePath ; fields: readonly string[] ; max_records: number ; scan_key?: string ; string_fields?: readonly WirePath[] ; parents?: { path: WirePath ; key: WirePath ; child_key: WirePath } } } | { kind: "opaque" } The body an admitted status carries. These are three different things. none is no body at all: a successful empty 204 declares it, and bytes arriving anyway violate the contract rather than being an empty success. json must parse and match the validator; malformed bytes are invalid at that status and never degrade to an empty success. opaque is bytes the host retains without interpreting, such as a provider answering an ordinary error with HTML or plain text. opaque is not “ignore any body”: the status is still evidence, and the body supplies no field evidence at all.

ResponseContract

Ƭ ResponseContract: Object What may be interpreted from a response. A status outside statuses is still retained, but proves only that the provider answered.

Type declaration

Name	Type	Description
`graphql?`	{ `media_types`: readonly `string`[] }	Checked on original retained bytes, before any projection or settlement.
`graphql.media_types`	readonly `string`[]	-
`statuses`	`Record`<`number`, `BodyContract`>	-
`headers?`	readonly `string`[]	Exact lowercase response headers retained for evidence; others drop.
`failures?`	readonly { `status`: `number` ; `kind`: `"transient"` \| `"unavailable"` \| `"insufficient_scope"` \| `"authentication"` \| `"signature"` \| `"throttled"` ; `when?`: { `kind`: `"text_equals"` ; `value`: `string` } \| { `kind`: `"any"` ; `items`: `WirePath` ; `path`: `WirePath` ; `value`: `ScalarValue` } \| { `kind`: `"all"` \| `"not_all"` ; `matches`: readonly { `path`: `WirePath` ; `value`: `ScalarValue` }[] } }[]	Acquisition only. Failed observations remain in custody, and transient failures back off under the same pinned request. Never retries a command.

ScalarValue

Ƭ ScalarValue: { type: "bool" ; value: boolean } | { type: "text" ; value: string } | { type: "integer" ; value: string } | { type: "null" } | { type: "missing" } An exact scalar a response field may equal. Matching is by type and value together, so false, "false", null and an absent field stay four different things. An integer is canonical decimal text compared against an exact JSON integer, never through a float.

KeyEncoding

Ƭ KeyEncoding: "text" | "integer" How one key component is read. integer preserves an exact provider identifier: a value that is not an exact JSON integer is refused rather than rounded, so a large numeric id never loses its low digits.

KindMatch

Ƭ KindMatch: Object

Type declaration

Name	Type
`value`	`ScalarValue`
`record`	`"present"` \| `"deleted"`

RecordKindSource

Ƭ RecordKindSource: { kind: "fixed" ; record: "present" | "deleted" } | { kind: "match" ; path: WirePath ; variants: readonly KindMatch[] } How a response says what each of its records is. Providers differ: one tags rows with a string, another with a boolean archived flag, and an endpoint that only ever returns live records says nothing at all.

KeyPart

Ƭ KeyPart: { kind: "literal" ; value: string } | { kind: "mapped_field" ; path: WirePath ; values: Record<string, string> } | HttpInput | { kind: "field" ; path: WirePath ; encoding: KeyEncoding } One component of a compound key. A provider returning association rows omits the parent it was asked about, so identity is completed from the admitted request context rather than from anything a response invented.

RecordKeySource

Ƭ RecordKeySource: { kind: "input" } & HttpInputReference | { kind: "field" ; path: WirePath ; encoding: KeyEncoding } | { kind: "compound" ; parts: readonly KeyPart[] } | { kind: "first_present" ; paths: readonly WirePath[] ; encoding: KeyEncoding } How each record’s key is assembled.

ResumeSource

Ƭ ResumeSource: { kind: "stated" ; from: Selector } | { kind: "when" ; from: Selector ; condition: Selector } | { kind: "while_more" ; from: Selector } | { kind: "link_relation" ; header: string ; relation: string } | { kind: "last_record_key" } | { kind: "maximum_field" ; path: WirePath } Where the position the NEXT acquisition request resumes from comes from. stated is the provider’s own cursor, read from the position it states it at. last_record_key is the after=<id> walk: the provider states no cursor and the next request continues after the LAST record this response returned, so the HOST derives the position from the keys it already verified against this same response’s declared key. The connector composes nothing, because a position the host cannot check against retained evidence is one a guest could move backwards over records already published. An empty page names no last row and therefore derives no position. maximum_field is the third, and it is the same derivation over a different value: the provider states no cursor and the next request continues from the LARGEST value a declared ordered field took over this page’s records — Odoo’s write_date >= <the largest one you saw>, and BigQuery’s APPENDS instant. It exists because neither other arm can say it: there is no stated cursor to select, and the last ROW’s key is a different value in a different domain from the one the request filters on. Two rules come with it. The values are compared as the PROVIDER spelled them, so every row must carry the field as text of one width — a fixed-width timestamp orders by bytes and "9" against "10" does not, so a page mixing widths is refused rather than positioned wrongly. And the continuation is INCLUSIVE of its own boundary, because the field’s rendering may be coarser than the comparison the provider makes on it: Odoo renders write_date to the second and compares at full stored precision, so a strict > returns the row it came from. The boundary row is therefore re-read on every resume, and the declaration owes an opaque record version so that the re-read row is deduplicated by (key, version) instead of churning history. That inclusiveness is also why the walk needs an end: the last page returns its boundary row and nothing else, and its maximum is the position the request already carried. The host derives a position only where what it computed is STRICTLY GREATER than the one this request resumed from, and an empty page derives none, so a finished walk exhausts instead of asking for the same page for ever.

RecordProjection

Ƭ RecordProjection: Object

Type declaration

Name	Type	Description
`collection`	`string`	-
`subject?`	`HttpInputReference`	-
`items?`	`WirePath`	-
`presence`	`RecordKindSource`	-
`key`	`RecordKeySource`	-
`version?`	`Selector`	-
`complete?`	`WirePath`	At most one of `complete`, `more` and `end_cursor`, as standalone `records` evidence declares it.
`more?`	`WirePath`	-
`end_cursor?`	`WirePath`	Completion is stated by an absent or empty string at this cursor.
`resume?`	`ResumeSource`	-

HttpEvidence

Ƭ HttpEvidence: { kind: "resources" ; items?: WirePath ; id: { path: WirePath ; encoding: KeyEncoding } ; label?: WirePath ; next_page?: WirePath } | { kind: "query_result" ; collection: string ; items: WirePath ; columns: WirePath ; column_names: readonly string[] ; key_prefix: readonly string[] ; key_columns: readonly number[] ; has_more: WirePath ; is_cached: WirePath ; calculated_at: WirePath ; calculated_at_field: string } | { kind: "identity" ; account?: { path: WirePath ; encoding: KeyEncoding } ; incarnation?: WirePath } | { kind: "feed" ; collection: string ; items: WirePath ; discriminator: WirePath ; variants: Record<string, { kind: "replace" | "delete" ; key: WirePath ; position: WirePath ; version?: WirePath }> ; through: WirePath ; head?: WirePath ; has_more: WirePath } | { kind: "records" ; collection: string ; subject?: HttpInputReference ; items?: WirePath ; parents?: WirePath ; sole?: WirePath ; presence: RecordKindSource ; key: RecordKeySource ; version?: Selector ; complete?: WirePath ; more?: WirePath ; end_cursor?: WirePath ; resume?: ResumeSource ; exact?: readonly { path: WirePath ; encoding: { kind: "decimal_string" } | { kind: "minor_units" ; scale: number } | { kind: "implied_decimals" ; scale: number } }[] } | { kind: "projections" ; records: readonly RecordProjection[] } | { kind: "incremental" ; collection: string ; items: WirePath ; also?: readonly WirePath[] ; items_optional?: boolean ; presence: RecordKindSource ; key: RecordKeySource ; version?: Selector ; removals?: { items: WirePath ; key: RecordKeySource } ; next_page: Selector ; next_sync: Selector ; missing_sync_token?: "refuse" | "retain_committed" ; terminal?: WirePath ; more?: WirePath ; sync_parameter: string ; page_parameter: string ; reset_status?: number ; restart?: { status: number ; code: WirePath ; values: readonly string[] } ; stated_coverage?: { path: WirePath ; values: Record<string, "complete" | "partial"> } } | { kind: "traversal" ; collection: string ; deletions: readonly string[] ; items: readonly { parents?: WirePath ; parents_optional?: boolean ; items: WirePath ; items_optional?: boolean ; key: WirePath ; version?: WirePath ; presence: RecordKindSource }[] ; duplicates: "present" | "deleted" | "last" ; next_page?: Selector ; checkpoint?: Selector ; checkpoint_name: string ; page_parameter?: string ; checkpoint_parameter?: string ; reset_status: number ; terminal_without_checkpoint?: boolean } | { kind: "discovery" ; keyset?: boolean ; collection: string ; items: WirePath ; presence: RecordKindSource ; key: RecordKeySource ; complete?: WirePath ; resume?: Selector ; continuation?: HttpInputReference } | { kind: "data" } | { kind: "checkpoint" ; name: string ; value: Selector } | { kind: "command" ; command: string ; operation_id?: never ; outcome: { kind: "status" } | { kind: "selected" ; from: Selector } | { kind: "by_status" ; selected: Record<number, Selector> } | { kind: "presence" ; of: WirePath } ; outcomes: Record<string, { kind: "confirmed" ; target_key?: Selector ; effects?: readonly { response: WirePath ; input: HttpArgumentReference }[] ; observation?: { key: WirePath ; position?: WirePath ; version?: WirePath ; record?: WirePath } } | { kind: "rejected" | "pending" | "unknown" } | { kind: "counted" } | { kind: "observed" } | { kind: "withdrawn" } | { kind: "refused" }> ; refusal?: { name: Selector ; kinds: Record<string, "precondition_failed" | "member_missing" | "invariant_violated" | "malformed" | "identity_reused"> ; member?: { on: string[] ; reasons: WirePath ; code: WirePath ; unaffected: string } ; current?: { kind: "body" ; path: WirePath } | { kind: "member" ; path: WirePath } } ; attribution?: { kind: "echoed" ; operation_id: Selector } | { kind: "searched" ; list?: WirePath ; operation_id: WirePath ; created_key?: WirePath ; complete?: WirePath ; more?: WirePath ; end_cursor?: WirePath ; page: number } | { kind: "absence" ; target_key: Selector } | { kind: "created" } ; created?: Selector ; created_encoding?: KeyEncoding }

HttpContract

Ƭ HttpContract: Object

Type declaration

Name	Type	Description
`grpc?`	`GrpcExchange`	-
`provider_work?`	{ `header`: `string` ; `path_prefix`: `string` }	-
`provider_work.header`	`string`	-
`provider_work.path_prefix`	`string`	-
`provider_task?`	readonly `string`[]	-
`process?`	{ `kind`: `"sandbox_process_v1"` ; `connection_url`: `WirePath` ; `command`: `HttpTemplate` ; `files?`: `Record`<`string`, `WirePath`> ; `timeout_seconds`: `number` ; `max_output_bytes`: `number` } \| { `kind`: `"sandbox_process_attach_v1"` ; `connection_url`: `WirePath` ; `timeout_seconds`: `number` ; `max_output_bytes`: `number` }	Process responses expose only status and exitCode. Full stdout/stderr remain in protected result-file custody, never in handler JSON.
`handler`	{ `member`: readonly `string`[] }	-
`handler.member`	readonly `string`[]	-
`method`	`"GET"` \| `"HEAD"` \| `"POST"` \| `"PUT"` \| `"PATCH"` \| `"DELETE"`	-
`route`	readonly ({ `kind`: `"literal"` ; `value`: `string` } \| `HttpInput` \| { `kind`: `"resume_path"` ; `prefix`: `string` } \| `Extract`<`HttpTemplate`, { `kind`: `"resource_segment"` }> \| `Extract`<`HttpTemplate`, { `kind`: `"concat"` }> \| `Extract`<`HttpTemplate`, { `kind`: `"key_component"` }>)[]	-
`path_scope?`	`"base"` \| `"origin_root"`	Where the route is anchored. `base` (the default) appends the route to the connection’s own resource URL. `origin_root` anchors it at the provider origin instead, which is admitted only for a listener `stop` contract whose route is entirely literal — the one endpoint that is not under the watched resource. Nothing else may leave the resource path.
`query`	`Record`<`string`, `HttpTemplate`>	-
`headers`	`Record`<`string`, `HttpTemplate`>	-
`body?`	`HttpTemplate`	-
`request_schema?`	`HttpRequestSchema`	-
`body_encoding?`	{ `kind`: `"protobuf"` ; `schema`: `GrpcSchema` ; `message`: `string` } \| { `kind`: `"file"` ; `content_type`: `string` ; `max_bytes`: `number` } \| { `kind`: `"raw"` ; `content_type`: `string` ; `encoding`: `"utf8"` \| `"base64url"` } \| { `kind`: `"multipart"` ; `subtype`: `"form_data"` \| `"related"` ; `parts`: readonly { `name`: `string` ; `filename?`: `string` ; `content_type`: `string` ; `encoding`: `"json"` \| `"utf8"` \| `"base64url"` \| { `file`: { `max_bytes`: `number` } } }[] }	Immutable bytes encoded before signing. `file` selects an accepted typed storage ID and streams its native bytes up to the declared bound. Multipart parts select fields of the body object. Names and media types are literals; encodings grant no filesystem or URL access.
`parameters?`	`Fields`	Values the integration supplies at call time; absent declares none.
`response`	`ResponseContract`	-
`next_page?`	{ `kind`: `"absolute"` ; `parameter`: `string` ; `contract`: `string` } \| { `kind`: `"query_from_url"` ; `parameter`: `string` ; `contract`: `string` } \| { `kind`: `"query"` ; `parameter`: `string` ; `contract`: `string` ; `query`: `string` }	How the next page of a paged GET is addressed from retained evidence. `parameter` names the declared parameter the integration passes the next page reference in; `contract` names the contract whose traversal or resource evidence supplies that next page, and it must belong to the same handler. Only a retained page of this group’s own basis may redirect the request, and every mode stays on the admitted origin and the declared resource path: - `absolute` takes the provider’s own next-page URL and REPLACES the declared query with the one that URL carries. The URL must have the same origin and the same path as the declared route. - `query_from_url` also REPLACES the declared query with the provider URL’s query, but keeps the declared path whatever path that URL had. - `query` keeps the declared query and APPENDS one more pair, named by `query`, carrying the provider’s opaque next-page token. That name may not collide with a declared query field. A next page is a resource-scoped GET: it is refused on any other method, on an origin-root path, and on a listener contract.
`retrieval?`	{ `parameter`: `string` ; `contract`: `string` ; `url`: `WirePath` }	The retrieval of an export the provider prepared at an address of its own choosing, and the one request that deliberately leaves the connection’s origin. `contract` names the contract whose retained response carried the address and `url` where in that response it sits; `parameter` is the typed parameter through which the caller cites that retained response. Guest code cites evidence it already holds and never names an address. Three host rules bound it, and none of them is declarable: the address must come from a retained response of THIS acquisition; it must be either the connection’s own origin or an `https` address at a named domain, never an IP literal, so no provider field can send the engine to loopback, to a link-local metadata service or into a private range; and no credential and no declared header travels with it, because a prepared export is authorized by its own address. Declared with `next_page`, or with a route, query, body or header, it is refused.
`retrieval.parameter`	`string`	-
`retrieval.contract`	`string`	-
`retrieval.url`	`WirePath`	-
`observation_lag_ms?`	`number`	How far behind the present this endpoint’s own answer is, in milliseconds, as a provider fact. A provider may deliberately withhold a window at the head of its change stream so that a record still being written cannot slip between two pages. Such an endpoint answers with what it could see a window ago and says nothing about it, so the declaration states it and the host SHIFTS this response’s whole observation window back by it before anything is retained: a view taken at `t` is a view of the world at `t - lag`. Every claim the response publishes then carries the shifted bounds, and a coverage record closed on it ends a window earlier. Omitted is zero, and zero is a claim: this endpoint’s answer speaks for the instant it was answered. It belongs only to a contract that publishes observations; a command receipt is not one. At most one hour.
`role?`	`string`	The CREDENTIAL ROLE this contract dispatches under. A role is protocol structure, which is why a definition names one and a deployment binds it: the definition states that this endpoint is authorized differently from the rest of the provider, and the deployment states where that role lives and which private credential it is. A definition names no secret and no address, and an operator reads no definition to learn what to provision. PagerDuty is the shape that needed it. Its write half is an events-ingest key in a request body on one host; its read half is an account key in an `Authorization` header on another; and the read half is not optional, because the reconcile IS the read — the ingest host answers `202` for a routing key that names nothing, so a REST read of the incident is the only evidence one exists. No single credential authorizes both halves. Omitted is the one unnamed default role, which is the connection’s own base URL and credential, and is what every single-credential definition means. A contract naming a role the connection does not hold is refused when the definition is bound to that connection, before any request exists.
`required_permissions?`	readonly `string`[]	Provider scopes required for this request. The host refuses missing or unestablished grants before dispatch; declaring a scope grants no authority. Omitted means this operation makes no provider-scope assertion.
`evidence`	`HttpEvidence`	-
`file?`	{ `collection`: `string` ; `parser`: `"mime"` ; `body`: { `kind`: `"whole"` } ; `max_bytes?`: `never` } \| { `collection`: `string` ; `parser`: `"mime"` ; `body`: { `kind`: `"json_base64"` ; `selector`: `WirePath` ; `encoding`: `"base64url"` } ; `max_bytes?`: `never` } \| { `collection`: `string` ; `parser`: `"bytes"` ; `body`: { `kind`: `"stream"` \| `"revalidate"` } ; `max_bytes`: `number` ; `checksum?`: { `algorithm`: `"sha256"` \| `"md5"` ; `encoding`: `"hex"` \| `"base64"` \| `"quoted_hex"` ; `header`: `string` ; `member?`: `string` } }	Host-owned parsing of retained response bytes into protected files. The host reads the declared bytes, parses them with the declared parser and attaches the resulting files to the named collection’s projected key; guest code never supplies bytes, a storage destination or a parser at runtime. The collection must be declared and must be one this response actually projects. `whole` requires every admitted successful status to carry an `opaque` body; `json_base64` requires every admitted successful status to carry a JSON body and selects the encoded bytes from one field path. `stream` is the third body and the only one the host never retains: the response bytes go straight into staged protected storage during acquisition, and what the host keeps is custody of them — the storage id, the exact size, the digest and the admitted headers — rather than the bytes. It is the response body itself, so it pairs only with the `bytes` parser, which interprets nothing, and only with opaque successful bodies. `max_bytes` is that pairing’s declared ceiling and belongs to it alone: a streamed body leaves no retained value to measure afterwards, so the bound has to be enforced while the bytes are written, and the other two bodies declare none. Its own ceiling is the protected file ceiling, 1 GiB; the transfer is timed by the bytes it moves and ends early only when it stops moving.

ResponseEvidence

Ƭ ResponseEvidence: string A reference is only a lookup key; native admission checks its invocation.

IdentityKey

Ƭ IdentityKey<S>: Extract<keyof S, string> | readonly [Extract<keyof S, string>, Extract<keyof S, string>, …Extract<keyof S, string>[]] Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Fields`

CommandsOf

Ƭ CommandsOf<I>: I extends { commands: infer C } ? C : {} Not exported: an exported type refers to it.

Type parameters

Name
`I`

Fields

Ƭ Fields: Record<string, GenericValidator> Not exported: an exported type refers to it.

HttpContracts

Ƭ HttpContracts: Record<string, HttpContract> Not exported: an exported type refers to it.

Declaration

Ƭ Declaration: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`isIntegration`	`true`
`_connectionSetup?`	`object`
`exportIntegration`	() => `string`

ResourceDeclaration

Ƭ ResourceDeclaration<Setup, S, Connector, ConnectionKeys, Credential, Commands>: ResourceTable<S> & { isIntegration: true ; isResource: true ; commands: Commands ; _connectionSetup?: Setup ; _connector?: Connector ; _credential?: Credential ; _connectionKeys?: ConnectionKeys ; exportIntegration: () => string } Stable public type used in emitted application declarations.

Type parameters

Name	Type
`Setup`	extends `object`
`S`	extends `Fields`
`Connector`	extends `string`
`ConnectionKeys`	extends `string`
`Credential`	extends `string`
`Commands`	extends `Record`<`string`, `CommandHandle`<`any`, `any`>> = {}

ResourceIdentity

Ƭ ResourceIdentity<S>: Object Provider identity fields are declared once and selected by acquisition and receipts.

Type parameters

Name	Type
`S`	extends `Fields` = `Fields`

Type declaration

Name	Type
`key`	`IdentityKey`<`S`>
`version?`	`Extract`<keyof `S`, `string`>

ResourceRead

Ƭ ResourceRead: Object A collection recipe receives the resource schema and identity exactly once.

Type declaration

Name	Type
`build`	<S>(`schema`: `S`, `identity`: `ResourceIdentity`<`S`>) => `CollectionDefinition`<`S`, `any`, `SourceProtocol`>

ResourceCommand

Ƭ ResourceCommand<A, Target>: Object A command recipe lowers to ordinary request contracts and governed handlers.

Type parameters

Name	Type
`A`	extends `Fields` = `Fields`
`Target`	extends `"record"` \| `"collection"` = `"record"`

Type declaration

Name	Type
`args`	`A`
`target`	`Target`
`build`	(`name`: `string`, `collection`: `string`, `schema`: `Fields`, `identity`: `ResourceIdentity`) => { `requests`: `HttpContracts` ; `command`: `CommandDefinition`<`A`, `Record`<`string`, `Fields`>, `any`> }

ResourceConnection

Ƭ ResourceConnection<Setup, Kind, Credential, Keys>: { kind: Kind ; credentialKind: Credential ; fields: readonly Keys[] ; address?: ResourceAddress ; requests: HttpContracts } & Pick<CallbackIntegrationDefinition<any, any, any, any, Setup>, "identify" | "discover" | "budget" | "backoff"> Shared connection behavior. Setup is declared once on the resource; fields selects the immutable connection-owned subset, and the remaining setup selects a resource on that connection. Private authentication stays in native custody.

Type parameters

Name	Type
`Setup`	extends `Fields` = `Fields`
`Kind`	extends `string` = `string`
`Credential`	extends `string` = `string`
`Keys`	extends `Extract`<keyof `Setup`, `string`> = `Extract`<keyof `Setup`, `string`>

ResourceOptions

Ƭ ResourceOptions<S>: Object

Type parameters

Name	Type
`S`	extends `Fields`

Type declaration

Name	Type	Description
`metadata?`	`SourceMetadataRequirement`	-
`access?`	`ReadAccess`	Installed as the ordinary table read/disclosure rule by defineTable.
`defaults?`	`object`	-
`address?`	`ResourceAddress`	-
`selection?`	`string`	-
`projection?`	{ readonly [K in keyof S]: Object }	-

ResourceGroupDeclaration

Ƭ ResourceGroupDeclaration<Setup, Tables, Connector, ConnectionKeys, Credential, Commands>: Object One binding and acquisition responsibility for several inseparable tables.

Type parameters

Name	Type
`Setup`	extends `object`
`Tables`	extends `object`
`Connector`	extends `string`
`ConnectionKeys`	extends `string`
`Credential`	extends `string`
`Commands`	extends `Record`<`string`, `CommandHandle`<`any`, `any`>> = {}

Type declaration

Name	Type
`isIntegration`	`true`
`isResource`	`true`
`tables`	`Tables`
`commands`	`Commands`
`_connectionSetup?`	`Setup`
`_connector?`	`Connector`
`_credential?`	`Credential`
`_connectionKeys?`	`ConnectionKeys`
`exportIntegration`	() => `string`

MultiResourceOptions

Ƭ MultiResourceOptions<I, T, C>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`I`	extends `Declaration`
`T`	extends `Record`<`string`, `SourceHandle`<`any`>>
`C`	extends `ConnectionDefinition`

Type declaration

Name	Type
`integration`	`I`
`tables`	`T`
`connection`	`C`
`selection?`	keyof `NonNullable`<`I`[`"_connectionSetup"`]> & `string`
`address?`	`ResourceAddress`
`defaults?`	`Partial`<`NonNullable`<`I`[`"_connectionSetup"`]>>

AccountIdentity

Ƭ AccountIdentity: { method: "GET" ; path: string ; query?: Readonly<Record<string, string>> ; requiredPermissions: readonly string[] ; subject: WirePath ; label?: WirePath } | { method: "signedAssertion" ; requiredPermissions: readonly string[] }

CollectionRecipe

Ƭ CollectionRecipe<S, P>: Object The request contract and collection a builder stands for once it is named.

Type parameters

Name	Type
`S`	extends `Fields`
`P`	extends `SourceProtocol`

Type declaration

Name	Type	Description
`request`	`object`	-
`requests?`	`Record`<`string`, `object`>	Additional requests executed by this collection’s same admitted reader.
`collection`	`CollectionDefinition`<`S`, `any`, `P`>	-

ResourceTable

Ƭ ResourceTable<S, Scope>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `GenericValidator`> = `Record`<`string`, `GenericValidator`>
`Scope`	extends `Record`<`string`, `Value`> = {}

Type declaration

Name	Type
`schema`	`S`
`[member]`	`SourceHandle`<`S`, `Scope`>
`resourceValidator`	`SourceHandle`<`S`, `Scope`>[`"resourceValidator"`]
`withScope`	<ScopeFields>(`fields`: `ScopeFields`) => `ResourceTable`<`S` & `ScopeFields`, `ObjectType`<`ScopeFields`>>

FieldsOfKind

Ƭ FieldsOfKind<S, Kind>: { [K in keyof S]: S[K][“isOptional”] extends “required” ? S[K][“kind”] extends Kind ? K : never : never }[keyof S] & string Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Fields`
`Kind`	extends `GenericValidator`[`"kind"`]

RecordDefinition

Ƭ RecordDefinition<S>: Object What one acquired event means. schema validates the decoded payload; time names its business instant, a required int64 field in an exact unit. History stores it as timestamptz; series uses exact microseconds. { kind: "change_feed", feed } reads a distributed SQL database’s change feed off Kafka into latest rows only: "cockroachdb" (CREATE CHANGEFEED ... WITH format = 'json', envelope = 'wrapped', updated, resolved) or "ticdc_canal_json" (TiCDC canal-json with enable-tidb-extension=true). The schema names the table’s columns; latest.key its primary key, in key order; latest.orderBy two int64 fields (CockroachDB: wall nanoseconds and logical) or one (TiCDC: the commit TSO) that the commit timestamp fills. A deletion withdraws its key, and rows are published only through the resolved frontier, the least resolved timestamp of every partition.

Type parameters

Name	Type
`S`	extends `Fields`

Type declaration

Name	Type
`schema`	`S`
`encoding`	`"json"` \| `"avro"` \| { `kind`: `"registry"` ; `event`: `EventDefinition` } \| { `kind`: `"change_feed"` ; `feed`: `"cockroachdb"` \| `"ticdc_canal_json"` }
`contract?`	`EventContractCapture`
`time?`	{ `field`: `FieldsOfKind`<`S`, `"int64"`> ; `unit`: `"seconds"` \| `"milliseconds"` \| `"microseconds"` }
`time.field`	`FieldsOfKind`<`S`, `"int64"`>
`time.unit`	`"seconds"` \| `"milliseconds"` \| `"microseconds"`

EventHistory

Ƭ EventHistory<S>: Object One Iceberg table of decoded events. history: true partitions by day and sorts by the declared record time, or uses no layout when time is absent. layout uses the same partition and sort grammar as datasets. Adding a nullable field or renaming one keeps the same history. Any other change to its columns, partition or sort is a new history: declare version: 2 (then 3, …), kept as dataset <export>_v2 and built from the raw archive, while the previous table stays readable and receives no more rows.

Type parameters

Name	Type
`S`	extends `Fields`

Type declaration

Name	Type	Description
`layout?`	`DatasetLayout`<`S`>	-
`version?`	`number`	-
`retentionDays?`	`number`	Keep event times at or after the committed retention floor. Requires record.time. Increasing or removing this window never restores expired events.

LatestProjection

Ƭ LatestProjection<S>: Object The latest row per key, published to the table bound with defineSyncedTable({ source: source.latest }). orderBy lists one to four distinct int64 fields compared in order, so ["eventTime", "sequence"] takes the newest instant and, at that instant, the newest correction. It defaults to the record time field.

Type parameters

Name	Type
`S`	extends `Fields`

Type declaration

Name	Type
`key`	readonly [`FieldsOfKind`<`S`, `"string"` \| `"int64"`>, …FieldsOfKind<S, “string” \| “int64”>[]]
`orderBy?`	readonly [`FieldsOfKind`<`S`, `"int64"`>, …FieldsOfKind<S, “int64”>[]]
`publishEvery`	`SyncEvery`
`freshness?`	`SyncEvery`

NativeSeriesOutput

Ƭ NativeSeriesOutput<S>: Object Accepted observations in a declared native series table in this component. The table’s payload is the record schema. Ordering is a business fact; Kafka offsets are comparable only within their own partitions.

Type parameters

Name	Type
`S`	extends `Fields`

Type declaration

Name	Type
`table`	`string`
`key`	`FieldsOfKind`<`S`, `"string"`>
`orderBy`	`FieldsOfKind`<`S`, `"int64"`>

KafkaTransport

Ƭ KafkaTransport: { kind: "kafka" ; correlation?: never } | { kind: "kafka" ; correlation: string } Kafka interpretation and acknowledgement semantics; routing is installed through binding setup.

EventBrokerTransport

Ƭ EventBrokerTransport: { kind: "pulsar" } | { kind: "jetstream" } | { kind: "rabbitmq" } | { kind: "redis" } | { kind: "kinesis" } | { kind: "pubsub" ; expectedTopic?: string ; correlation?: string } | { kind: "sqs" ; envelope?: "sns" } | { kind: "servicebus" } | { kind: "rabbitmq_queue" } | { kind: "mqtt" ; identity: readonly string[] ; correlation?: string } | { kind: "stomp" } Raw broker routing; physical endpoints and subscriptions are privately installed.

PostgresTransport

Ƭ PostgresTransport: Object A PostgreSQL logical replication slot, pgoutput protocol v1. Physical relation names, publication and credentials are private installation configuration and are never declared here.

Type declaration

Name	Type	Description
`debezium?`	{ `runtime_version`: `string` ; `contract`: { `decoderRevision`: `string` ; `schemaDigest`: `string` ; `tables`: `Record`<`string`, { `columns`: `Record`<`string`, { `key`: `boolean` ; `nullable`: `boolean` ; `typeModifier`: `number` ; `typeOid`: `number` }> }> } }	Customer-hosted Debezium supplies the same transactional PostgreSQL source contract. Physical configuration is private installation state.
`debezium.runtime_version`	`string`	-
`debezium.contract`	{ `decoderRevision`: `string` ; `schemaDigest`: `string` ; `tables`: `Record`<`string`, { `columns`: `Record`<`string`, { `key`: `boolean` ; `nullable`: `boolean` ; `typeModifier`: `number` ; `typeOid`: `number` }> }> }	-
`debezium.contract.decoderRevision`	`string`	-
`debezium.contract.schemaDigest`	`string`	-
`debezium.contract.tables`	`Record`<`string`, { `columns`: `Record`<`string`, { `key`: `boolean` ; `nullable`: `boolean` ; `typeModifier`: `number` ; `typeOid`: `number` }> }>	-

MailboxTransport

Ƭ MailboxTransport: Object One mailbox session. The account, endpoint, selected folders and credentials are private installation configuration; a declaration names only the three projections it publishes.

Type declaration

Name	Type	Description
`provider`	`"imap"`	-
`messages`	`string`	-
`contents`	`string`	-
`memberships`	`string`	-
`attachments?`	readonly { `media_types`: readonly `string`[] ; `document`: `DocumentDeclaration` }[]	Attachments the host decodes as documents, by lowercase media type (`type/subtype`, without parameters; one media type belongs to one declaration; at most eight declarations of at most eight types). Each matching attachment is listed in the contents row’s `attachment_documents` with its decoded `value`, or a `refusal` when its bytes do not decode. The attachment itself stays a protected file.

EventAcquisitionTransport

Ƭ EventAcquisitionTransport: Object Bounded native ingestion: the raw archive, the typed event history and the latest rows of one topic, with command correlation. Broker and registry connection details stay in private installation data. Acquisition uses the ordinary source schedule; the latest policy independently bounds database publication. Acknowledgements never replace rows.

Type declaration

Name	Type	Description
`raw_archive?`	`true`	Retain original source bytes in the source’s raw archive dataset.
`record?`	{ `schema`: `unknown` ; `encoding`: { `kind`: `"json"` \| `"avro"` } \| { `kind`: `"registry"` ; `event`: `EventDefinition` } \| { `kind`: `"change_feed"` ; `feed`: `"cockroachdb"` \| `"ticdc_canal_json"` } ; `contract?`: `EventContractCapture` ; `time?`: { `field`: `string` ; `unit`: `"seconds"` \| `"milliseconds"` \| `"microseconds"` } }	What one event means, declared once for every decoded output.
`record.schema`	`unknown`	The `v.object` validator JSON of the record schema.
`record.encoding`	{ `kind`: `"json"` \| `"avro"` } \| { `kind`: `"registry"` ; `event`: `EventDefinition` } \| { `kind`: `"change_feed"` ; `feed`: `"cockroachdb"` \| `"ticdc_canal_json"` }	-
`record.contract?`	`EventContractCapture`	-
`record.time?`	{ `field`: `string` ; `unit`: `"seconds"` \| `"milliseconds"` \| `"microseconds"` }	-
`record.time.field`	`string`	-
`record.time.unit`	`"seconds"` \| `"milliseconds"` \| `"microseconds"`	-
`history?`	{ `layout?`: `NamedDatasetLayout` ; `version?`: `number` ; `retention_days?`: `number` ; `identities?`: `Record`<`string`, `number`> }	One Iceberg table of decoded events. Field identities come from the generated identity ledger, never from the author.
`history.layout?`	`NamedDatasetLayout`	-
`history.version?`	`number`	A later history dataset after an incompatible change; absent is 1.
`history.retention_days?`	`number`	-
`history.identities?`	`Record`<`string`, `number`>	-
`series?`	{ `table`: `string` ; `key`: `string` ; `order_by`: `string` }	A local native series table with the same typed payload as record.
`series.table`	`string`	-
`series.key`	`string`	-
`series.order_by`	`string`	-
`correlation?`	`string`	Field carrying the durable operation identity on acknowledgement records. Reserved outside the row schema; missing or null means an ordinary row.

SqlTransport

Ƭ SqlTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`collection`	`string`
`dialect`	`"mysql"` \| `"mariadb"` \| `"sqlserver"` \| `"oracle"` \| `"hana"` \| `"snowflake"` \| `"databricks"` \| `"jdbc"` \| `"duckdb"` \| `"clickhouse"` \| `"trino"` \| `"presto"` \| `"bigquery"` \| `"redshift"` \| `"athena"` \| `"synapse"` \| `"teradata"` \| `"db2"` \| `"vertica"` \| `"singlestore"` \| `"greenplum"` \| `"hive"` \| `"spark"`
`fields`	`Record`<`string`, `string`>
`key`	readonly `string`[]
`changes`	{ `kind`: `"read_only"` } \| { `kind`: `"watermark"` ; `column`: `string` ; `deletions?`: { `every`: `SyncEvery` } } \| { `kind`: `"source_changes"` }
`version?`	{ `kind`: `"column"` ; `column`: `string` } \| { `kind`: `"row_image"` }
`writes?`	`Record`<`string`, `"update"` \| `"delete"` \| `"insert"`>

BayeuxTransport

Ƭ BayeuxTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`raw_archive?`	`true`
`collection`	`string`
`wire`	{ `kind`: `"cometd"` ; `path`: `string` } \| { `kind`: `"pubsub"` ; `endpoint`: `string` }
`identity`	{ `path`: `string` ; `field`: `string` }
`identity.path`	`string`
`identity.field`	`string`
`events`	{ `kind`: `"named"` ; `field`: `string` } \| { `kind`: `"changes"` ; `header`: `string` ; `change`: `string` ; `transaction`: `string` ; `sequence`: `string` ; `entity`: `string` ; `gap`: `string` ; `accepted`: readonly `string`[] }

SalesforceTransport

Ƭ SalesforceTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`collection`	`string`
`api_version`	`string`
`object`	`string`
`fields`	`Record`<`string`, `string`>
`initial?`	`"query"` \| `"bulk"`

As2Transport

Ƭ As2Transport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`collection`	`string`
`document`	`DocumentDeclaration`
`items`	readonly `string`[]
`max_message_bytes?`	`number`
`writes?`	`Record`<`string`, `"deliver"`>

SftpTransport

Ƭ SftpTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`collection`	`string`
`max_inline_bytes`	`number`
`max_file_bytes?`	`number`
`max_depth?`	`number`
`writes?`	`Record`<`string`, `"create"` \| `"replace"` \| `"remove"`>
`document?`	`DocumentDeclaration`
`release?`	`SftpRelease`

SftpRelease

Ƭ SftpRelease: { kind: "remove" } | { kind: "archive" ; directory: string } Not exported: an exported type refers to it.

ODataTransport

Ƭ ODataTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`dataverse?`	{ `logical_name`: `string` ; `entity_set`: `string` ; `fields`: `Record`<`string`, `SourceMetadataField`> }
`dataverse.logical_name`	`string`
`dataverse.entity_set`	`string`
`dataverse.fields`	`Record`<`string`, `SourceMetadataField`>
`actions?`	`Record`<`string`, { `name`: `string` ; `parameters`: `string`[] }>
`collection`	`string`
`fields`	`Record`<`string`, `string`>
`key`	`string`[]
`etags?`	`boolean`
`filter?`	`Record`<`string`, `string`[]>
`key_types?`	`Record`<`string`, `"string"` \| `"integer"` \| `"guid"`>
`writes?`	`Record`<`string`, `"update"` \| `"delete"` \| `"insert"` \| `"action"`>
`repeatable?`	`boolean`
`marker?`	`string`
`navigations?`	`Record`<`string`, { `property`: `string` ; `fields`: `Record`<`string`, `string`> ; `max`: `number` }>

BijectionTransport

Ƭ BijectionTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`collection`	`string`
`fields`	`Record`<`string`, `string`>
`writes?`	`Record`<`string`, `string`>

DatasetTransport

Ƭ DatasetTransport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`collection`	`string`
`dataset`	`string`
`selection?`	`string`
`fields`	`Record`<`string`, `string`>

AcquisitionTransport

Ƭ AcquisitionTransport: { transport: "postgres" ; value: PostgresTransport } | { transport: "mailbox" ; value: MailboxTransport } | { transport: "kafka" ; value: EventAcquisitionTransport } | { transport: "broker" ; value: { protocol: Exclude<EventBrokerTransport, { kind: "pubsub" }> | { kind: "pubsub" ; expected_topic?: string } ; collection?: string ; events?: EventAcquisitionTransport } } | { transport: "dynamo_db" ; value: { collection: string } } | { transport: "salesforce" ; value: SalesforceTransport } | { transport: "git" ; value: { collection: string } } | { transport: "big_query" ; value: { collection: string } } | { transport: "sheets" ; value: { collection: string ; columns: number ; page_rows: number ; enrollment_rows: number ; writes?: Record<string, { columns: Record<string, number> }> } } | { transport: "kubernetes" ; value: { collection: string ; projection?: "pod" } } | { transport: "bayeux" ; value: BayeuxTransport } | { transport: "mongo" ; value: { collections: Record<string, { fields: Record<string, string> }> ; page_rows: number ; max_depth: number ; max_values: number } } | { transport: "sql" ; value: SqlTransport } | { transport: "dataset" ; value: DatasetTransport } | { transport: "bijection" ; value: BijectionTransport } | { transport: "sftp" ; value: SftpTransport } | { transport: "odata" ; value: ODataTransport } | { transport: "as2" ; value: As2Transport } The declared transport. The discriminator is spelled transport because that is what it selects; there is no acquisition kind beside it.

HttpWireSchema

Ƭ HttpWireSchema: { kind: "null" | "boolean" | "json" } | { kind: "string" ; min_length?: number ; max_length?: number ; pattern?: string } | { kind: "number" ; integer: boolean ; minimum?: number ; maximum?: number } | { kind: "literal" ; value: string | number | boolean | null } | { kind: "array" ; items: HttpWireSchema ; min_items?: number ; max_items?: number } | { kind: "object" ; fields: Record<string, { required: boolean ; schema: HttpWireSchema }> ; forbidden?: readonly string[] ; additional: { kind: "allow" | "deny" } | { kind: "schema" ; schema: HttpWireSchema } } | { kind: "union" ; variants: readonly HttpWireSchema[] ; exclusive: boolean } Compiled, bounded wire contracts. The native HTTP owner checks these before dispatch and before projecting a provider response into its native validator.

HttpRequestSchema

Ƭ HttpRequestSchema: Object

Type declaration

Name	Type	Description
`graphql?`	`unknown`	Opaque captured selection IR, admitted and rendered by the native host.
`route`	`Record`<`number`, `HttpWireSchema`>	-
`query`	`Record`<`string`, { `required`: `boolean` ; `schema`: `HttpWireSchema` }>	-
`headers`	`Record`<`string`, { `required`: `boolean` ; `schema`: `HttpWireSchema` }>	-
`body?`	`HttpWireSchema`	-
`origin?`	{ `operation_id`: `string` ; `source`: `string` ; `digest`: `string` }	-
`origin.operation_id`	`string`	-
`origin.source`	`string`	-
`origin.digest`	`string`	-
`authentication?`	{ `kind`: `"bearer"` } \| { `kind`: `"api_key"` ; `name`: `string` }	-

SyncInput

Ƭ SyncInput: FeedInput | IncrementalInput | EnumerationInput | SweepInput The read arguments of one acquisition. Untagged, because that is the shipped wire and the guest branches on which fields are present. The three shapes have disjoint required fields and each refuses unknown ones, so the union stays unambiguous in both directions.

FeedInput

Ƭ FeedInput: Object

Type declaration

Name	Type
`checkpoint`	`string`

IncrementalInput

Ƭ IncrementalInput: Object

Type declaration

Name	Type	Description
`sync_token`	`string` \| `null`	Rendered even when absent: the guest reads a present `null` as “no membership token yet”, which is a different fact from a missing field.
`page_token`	`string` \| `null`	-

EnumerationInput

Ƭ EnumerationInput: Object

Type declaration

Name	Type	Description
`position`	`string` \| `null`	Engine-owned. Constructed locally, never presented to a provider, compared with a provider value, or described as a resume cursor.
`resume`	`string` \| `null`	The provider’s own resume cursor within that position.
`discovery`	`DiscoverySlice` \| `null`	The retained listing slice this fanout resolves. Work input, not a guest cursor and not a new provider observation.
`batch_size`	`number`	-

DiscoverySlice

Ƭ DiscoverySlice: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`evidence`	`string`
`items`	`DiscoveredItem`[]

DiscoveredItem

Ƭ DiscoveredItem: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`item_index`	`number`
`key`	`string`
`kind`	`RecordKind`
`resume`	`string` \| `null`

RecordKind

Ƭ RecordKind: "present" | "deleted" Not exported: an exported type refers to it.

SweepInput

Ƭ SweepInput: Object One batch of a reconciliation sweep: the keys this engine has already published that this pass is to read again. The keys are the HOST’s, resolved from publication and pinned on the acquisition’s own start, so the read that goes out is addressed at a key the engine holds rather than one a connector chose. There is no cursor here and no listing: a sweep asks the provider about named records and the provider answers about exactly those.

Type declaration

Name	Type
`keys`	`string`[]
`batch_size`	`number`

CoupledInput

Ƭ CoupledInput: Object What the host gives one coupled acquisition attempt. Every field is host state the attempt is checked against, and none of it is something an integration may invent. It is its own shape rather than a member of SyncInput because a coupled group has its own reader: the group’s coupling.read is called with this, a collection’s own sync.read is called with a SyncInput, and no handler ever receives both.

Type declaration

Name	Type	Description
`baseline_owed`	`boolean`	An initial enumeration is still owed, so the reader should traverse rather than read changes.
`checkpoints`	`Record`<`string`, `CoupledCheckpoint`>	The provider progress marks this group actually retains, each with the response that proved it. Sorted by collection, which is also the order the retained group state iterates in.
`next_page_reference`	`string` \| `null`	The retained tail page this traversal resumes from, or absent to start. No other page is accepted.
`phase`	`CoupledPhase`	-
`batch_size`	`number`	-

CoupledCheckpoint

Ƭ CoupledCheckpoint: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`value`	`string`
`evidence`	`string`

CoupledPhase

Ƭ CoupledPhase: { kind: "traversal" } | { kind: "fanout" ; keys: string[] ; terminal: boolean } Not exported: an exported type refers to it.

ChangeFeedResult

Ƭ ChangeFeedResult<T>: Object What one change-feed read claims.

Type parameters

Name
`T`

Type declaration

Name	Type
`evidence`	`string`
`changes`	`Observation`<`T`>[]
`next_checkpoint`	`string`
`observed_head?`	`string`
`has_more`	`boolean`

Observation

Ƭ Observation<T>: { kind: "replace" ; evidence: string ; item_index: number ; key: string ; position: string ; version?: string ; value: T } | { kind: "delete" ; evidence: string ; item_index: number ; key: string ; position: string } One observed change in an ordered feed. evidence cites the retained response that proved it; item_index is the item’s position within that response, which is how the host matches a guest’s interpretation to the evidence rather than trusting its order. A feed item is a replacement or a deletion, and both carry the position the provider stated. There is no third case: a feed that cannot say which of the two an item is has no evidence contract here.

Type parameters

Name
`T`

RecordResult

Ƭ RecordResult<T>: ResetResult | EnumerationResult<T> | FanoutResult<T> | KeyedFanoutResult<T> | SweepResult<T> | SnapshotResult<T> What one record-observation read claims. Untagged, because that is the shipped wire: the guest returns a bare object and branches on which fields it filled. The four shapes are told apart by fields no other shape admits — reset, next_page/next_sync, complete, unresolved — and each refuses the others’ fields, so the union stays unambiguous in both directions.

Type parameters

Name
`T`

ResetResult

Ƭ ResetResult: Object

Type declaration

Name	Type	Description
`evidence`	`string`	-
`reset`	`true`	Always true. A `reset: false` is not a reset and is not this shape; it is the absence of the field, which is every other shape.

EnumerationResult

Ƭ EnumerationResult<T>: Object

Type parameters

Name
`T`

Type declaration

Name	Type	Description
`evidence`	`string`	-
`records`	`RecordObservation`<`T`>[]	-
`complete`	`boolean`	Enumeration coverage, claimable only where the protocol declares it. A traversal with parents still to visit is not complete, whatever the current page said.
`next_position?`	`string`	Where this connector’s scan continues. Engine-owned, never a provider value, and never spelled as though it were a continuation.
`next_resume?`	`string`	The provider’s continuation within the current position.

RecordObservation

Ƭ RecordObservation<T>: { kind: "present" ; evidence: string ; item_index: number ; key: string ; version?: string ; value: T } | { kind: "deleted" ; evidence: string ; item_index: number ; key: string } One observed record. version is an opaque equality token and never a position; a deletion carries neither a version nor a value, because a record the provider says is gone has no state to project.

Type parameters

Name
`T`

FanoutResult

Ƭ FanoutResult<T>: Object Not exported: an exported type refers to it.

Type parameters

Name
`T`

Type declaration

Name	Type
`evidence`	`string`
`records`	`RecordObservation`<`T`>[]
`unresolved`	`UnresolvedRecord`[]

UnresolvedRecord

Ƭ UnresolvedRecord: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`key`	`string`
`evidence`	`string`

KeyedFanoutResult

Ƭ KeyedFanoutResult<T>: Object Not exported: an exported type refers to it.

Type parameters

Name
`T`

Type declaration

Name	Type
`evidence`	`string`
`pages`	`KeyPage`<`T`>[]
`unresolved`	`UnresolvedRecord`[]

KeyPage

Ƭ KeyPage<T>: Object Not exported: an exported type refers to it.

Type parameters

Name
`T`

Type declaration

Name	Type
`key`	`string`
`evidence`	`string`
`records`	`RecordObservation`<`T`>[]
`next_resume?`	`string`

SweepResult

Ƭ SweepResult<T>: Object Not exported: an exported type refers to it.

Type parameters

Name
`T`

Type declaration

Name	Type
`records`	`RecordObservation`<`T`>[]
`unresolved`	`UnresolvedRecord`[]

SnapshotResult

Ƭ SnapshotResult<T>: Object

Type parameters

Name
`T`

Type declaration

Name	Type
`evidence`	`string`
`records`	`RecordObservation`<`T`>[]
`progress`	`SnapshotProgress`

SnapshotProgress

Ƭ SnapshotProgress: { kind: "continue" ; token: string } | { kind: "complete" ; resume: SnapshotResume } Exactly one evidenced transition of an incremental membership acquisition.

SnapshotResume

Ƭ SnapshotResume: { kind: "advance" ; token: string } | { kind: "retain_committed" } A missing response token never manufactures a new acquisition basis.

SourceMetadataProvider

Ƭ SourceMetadataProvider: { kind: "salesforce" ; api_version: string } | { kind: "odata" ; version: "v2" | "v4" } | { kind: "netsuite" } | { kind: "dataverse" ; api_version: "v9.2" } | { kind: "servicenow" ; api_version: "v1" } Captured provider descriptions. Runtime authority and coverage come from native connection and acquisition admission, independently of these types.

SourceMetadataField

Ƭ SourceMetadataField: Object

Type declaration

Name	Type
`optional?`	`boolean`
`native_type`	`string`
`encoding`	`string`
`length_facet`	`string` \| `null`
`picklist_values`	{ `value`: `string` ; `active`: `boolean` ; `default`: `boolean` ; `labels?`: `Record`<`string`, `string`> }[]
`representation`	`"string"` \| `"boolean"` \| `"float64"` \| `"decimal_text"` \| `"reference"` \| `"unsupported"`
`nullable`	`boolean`
`length`	`number` \| `null`
`precision`	`number` \| `null`
`scale`	`string` \| `null`
`reference_to`	`string`[]
`readable`	`boolean`
`createable`	`boolean`
`updateable`	`boolean`
`external_id`	`boolean`
`unique`	`boolean`

SourceFieldMeaning

Ƭ SourceFieldMeaning: Object

Type declaration

Name	Type
`labels`	`Record`<`string`, `string`>
`currency`	`string`[] \| `null`
`unit`	`string`[] \| `null`
`text`	`string`[] \| `null`
`language`	`boolean`

SourceSemantics

Ƭ SourceSemantics: Object

Type declaration

Name	Type
`lookups`	`Record`<`string`, { `collection`: `string` ; `parameters`: { `kind`: `string` ; `local`: `string` \| `null` ; `remote`: `string` }[] }>
`actions`	`Record`<`string`, { `parameters`: `Record`<`string`, `SourceMetadataField`> ; `return_type`: `string` \| `null` }>
`fields`	`Record`<`string`, `SourceFieldMeaning`>
`joins`	`Record`<`string`, { `target`: `string` ; `pairs`: { `source`: `string` ; `target`: `string` }[] ; `collection`: `boolean` ; `origin`: `string` }>
`unsupported`	`string`[]

SourceMetadataObject

Ƭ SourceMetadataObject: Object

Type declaration

Name	Type
`semantics`	`SourceSemantics`
`acquisition_profile`	`string` \| `null`
`native_type`	`string`
`keys`	`string`[]
`fields`	`Record`<`string`, `SourceMetadataField`>
`relationships`	{ `name`: `string` ; `field`: `string` \| `null` ; `targets`: `string`[] ; `collection`: `boolean` }[]
`queryable`	`boolean`
`retrieveable`	`boolean`

CapturedSourceSchema

Ƭ CapturedSourceSchema: Object

Type declaration

Name	Type
`format`	`"bijection.source-metadata.v2"`
`normalizer_version`	`"2"`
`provider`	`SourceMetadataProvider`
`objects`	`Record`<`string`, `SourceMetadataObject`>

SourceMetadataRequirement

Ƭ SourceMetadataRequirement: Object

Type declaration

Name	Type
`provider`	`SourceMetadataProvider`
`object`	`string`
`schema`	`SourceMetadataObject`
`reference_targets`	`Record`<`string`, `string`[]>

Properties

post

• post: (shape: RequestShape) => RequestBuilder

Type declaration

▸ (shape): RequestBuilder

Parameters

Name	Type
`shape`	`RequestShape`

Returns

RequestBuilder

Variables

http

• Const http: Readonly<{ setup: (name: string) => HttpValue<string> ; parameter: <T>(name: string) => HttpValue<T> ; get: (shape: RequestShape) => RequestBuilder ; post: (shape: RequestShape) => RequestBuilder ; put: (shape: RequestShape) => RequestBuilder ; patch: (shape: RequestShape) => RequestBuilder ; delete: (shape: RequestShape) => RequestBuilder }> Request builders describe ordinary admitted HTTP templates. Their callbacks run at declaration time and cannot read credentials or perform provider I/O.

identity

• Const identity: Readonly<{ field: <F>(field: F) => F ; tuple: <F>(…fields: F) => F }> A tuple’s ordered fields are part of its identity, never a display format.

Functions

admitIntegration

▸ admitIntegration<T>(definition): T Admit an integration definition authored outside this deployment component. A definition’s module/export address is assigned by the compiler and names a module of the deployment being installed. A definition imported from a package or a sibling directory is not such a module, so it has no address of its own and cannot be bound by defineSyncedTable({ source: collection }). Re-exporting it through this function from a module of the component gives it that module’s address:

import { admitIntegration } from "bijection/connectors";
import { storefront as slice } from "../commerce-providers/storefront";
export const storefront = admitIntegration(slice);

The definition is returned unchanged, so the address belongs to the admitted definition and never to a copy of it; the deployment independently checks that the address resolves to this same object. Admitting one definition twice, or admitting one that already carries an address, is refused by the definition itself, which is what keeps one authored collection bound to one table per component.

Type parameters

Name	Type
`T`	extends `Object`

Parameters

Name	Type
`definition`	`T`

Returns

T

defineAccountIntegration

▸ defineAccountIntegration(definition): Object Declare an account identity without an acquisition reader.

Parameters

Name	Type
`definition`	`AccountIdentityDefinition`

Returns

Object

Name	Type
`isIntegration`	`true`
`[attachment]`	(`next`: `IntegrationAddress`) => `void`
`exportIntegration`	() => `string`

defineExecutor

▸ defineExecutor<Engine>(definition?): Object Declare an execution capability. Its engine, inputs and credentials are installed by deployment administration. It schedules no acquisition.

Type parameters

Name	Type
`Engine`	extends `"trino"` \| `"presto"` \| `"bigquery"` \| `"clickhouse"` \| `undefined` = `undefined`

Parameters

Name	Type
`definition`	`Object`
`definition.engine?`	`Engine`
`definition.label?`	`string`

Returns

Object

Name	Type
`isIntegration`	`true`
`_connectionSetup?`	{ `tables`: `undefined` \| `Record`<`string`, { captured?: { digest: string; definition: string; }; schema: string; table: string; catalog: string; columns: Record<string, string>; }> ; `table`: `undefined` \| { schema?: string \| null; database?: string \| null; name: string; } ; `receipts`: `undefined` \| `null` \| { schema?: string \| null; database?: string \| null; name: string; } ; `changeRecord`: `undefined` \| `null` \| { kind: “capture”; captureInstance: string; } \| { root?: { properties?: Record<string, string>; database?: string \| null; port?: number \| null; instance?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { …; } \| { …; } \| null; kind: “logminer”; } ; `icebergCatalogs`: `undefined` \| `Record`<`string`, `string`> ; `connection`: { kind: “clickhouse”; endpoint: string; } \| { kind: “executor”; engine: string; endpoint: string; } \| { kind: “gateway”; endpoint: string; connection: { properties?: Record<string, string>; database?: string \| null; port?: number \| null; instance?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { …; } \| { …; }; } \| { role?: string \| null; kind: “snowflake”; endpoint: string; warehouse: string; } \| { kind: “bigquery”; endpoint: string; project: string; location: string; maxBytesBilled: string; } \| { kind: “databricks”; endpoint: string; warehouseId: string; } \| { kind: “clickhouse”; endpoint: string; } \| { kind: “bigquery”; endpoint: string; project: string; location: string; maxBytesBilled: string; } \| { kind: “executor”; engine: Engine & {}; endpoint: string; } }
`_connectionSetup.tables`	`undefined` \| `Record`<`string`, { captured?: { digest: string; definition: string; }; schema: string; table: string; catalog: string; columns: Record<string, string>; }>
`_connectionSetup.table`	`undefined` \| { schema?: string \| null; database?: string \| null; name: string; }
`_connectionSetup.receipts`	`undefined` \| `null` \| { schema?: string \| null; database?: string \| null; name: string; }
`_connectionSetup.changeRecord`	`undefined` \| `null` \| { kind: “capture”; captureInstance: string; } \| { root?: { properties?: Record<string, string>; database?: string \| null; port?: number \| null; instance?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { …; } \| { …; } \| null; kind: “logminer”; }
`_connectionSetup.icebergCatalogs`	`undefined` \| `Record`<`string`, `string`>
`_connectionSetup.connection`	{ kind: “clickhouse”; endpoint: string; } \| { kind: “executor”; engine: string; endpoint: string; } \| { kind: “gateway”; endpoint: string; connection: { properties?: Record<string, string>; database?: string \| null; port?: number \| null; instance?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { …; } \| { …; }; } \| { role?: string \| null; kind: “snowflake”; endpoint: string; warehouse: string; } \| { kind: “bigquery”; endpoint: string; project: string; location: string; maxBytesBilled: string; } \| { kind: “databricks”; endpoint: string; warehouseId: string; } \| { kind: “clickhouse”; endpoint: string; } \| { kind: “bigquery”; endpoint: string; project: string; location: string; maxBytesBilled: string; } \| { kind: “executor”; engine: Engine & {}; endpoint: string; }
`schema`	{}
`kind`	`"relational"`
`engine`	`undefined` \| `Engine`
`[sourceExport]`	() => { `version`: `1` ; `integration`: `IntegrationAddress` = address; `collection`: `string` = “executor” }
`[attachment]`	(`next`: `IntegrationAddress`) => `void`
`exportIntegration`	() => `string`

defineIntegration

▸ defineIntegration<S, H, A, R, L, T, C, D>(definition): Integration<S, H, A, R, L, T, keyof C extends never ? NativeSetupFor<D> : C>

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`> = {}
`H`	extends `HttpContracts` = {}
`A`	extends `Record`<`string`, `Fields`> = {}
`R`	extends `Fields` = {}
`L`	extends `LatestProjection`<`R`> \| `undefined` = `undefined`
`T`	extends `Record`<`string`, `unknown`> = {}
`C`	extends `Fields` = {}
`D`	extends `AcquisitionTransport` \| `KafkaTransport` \| `EventBrokerTransport` = `AcquisitionTransport` \| `KafkaTransport` \| `EventBrokerTransport`

Parameters

Name	Type
`definition`	`Omit`<`TransportIntegrationDefinition`<`S`, `H`, `A`, `R`, `L`, `T`, `C`>, `"discover"`> & { `transport`: `D` ; `discover?`: `TransportIntegrationDefinition`<`S`, `H`, `A`, `R`, `L`, `T`, keyof `C` extends `never` ? `NativeSetupFor`<`D`> : `C`>[`"discover"`] }

Returns

Integration<S, H, A, R, L, T, keyof C extends never ? NativeSetupFor<D> : C> ▸ defineIntegration<S, A, H, T, C>(definition): ReturnType<typeof defineCallbackIntegration>

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`A`	extends `Record`<`string`, `Fields`>
`H`	extends `Record`<`string`, `HttpContract` & { `browser?`: `never` }> = {}
`T`	extends `Record`<`string`, `unknown`> = {}
`C`	extends `Fields` = {}

Parameters

Name	Type
`definition`	`CallbackIntegrationDefinition`<`S`, `A`, `H`, `T`, `C`>

Returns

ReturnType<typeof defineCallbackIntegration>

defineHttpTelemetry

▸ defineHttpTelemetry<R, H, C>(definition): Integration<{ latest: R }, H, {}, {}, undefined, {}, C> One signed HTTP occurrence contributes to the same native event outputs.

Type parameters

Name	Type
`R`	extends `Fields`
`H`	extends `Record`<`string`, `HttpContract` & { `browser?`: `never` }> = {}
`C`	extends `Fields` = {}

Parameters

Name	Type
`definition`	`HttpTelemetryDefinition`<`R`, `H`, `C`>

Returns

Integration<{ latest: R }, H, {}, {}, undefined, {}, C>

defineCallbackIntegration

▸ defineCallbackIntegration<S, A, H, T, C>(definition): Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`A`	extends `Record`<`string`, `Fields`>
`H`	extends `Record`<`string`, `HttpContract` & { `browser?`: `never` }> = {}
`T`	extends `Record`<`string`, `unknown`> = {}
`C`	extends `Fields` = {}

Parameters

Name	Type
`definition`	`CallbackIntegrationDefinition`<`S`, `A`, `H`, `T`, `C`>

Returns

Object

createGrpcMessageValidator

▸ createGrpcMessageValidator<T>(schema, message): VObject<T, MessageFields<T>> Exact SDK validators derived from the same captured descriptor as native encoding. The host additionally enforces numeric ranges and wire bounds.

Type parameters

Name	Type
`T`	extends `Record`<`string`, `unknown`>

Parameters

Name	Type
`schema`	`GrpcSchema`
`message`	`string`

Returns

VObject<T, MessageFields<T>>

createGrpcMethod

▸ createGrpcMethod<I, O>(schema, method): GrpcMethod<I, O> Called by the captured-source preparer. Native admission rechecks the digest, descriptors, field selectors, request role and full resolved input.

Type parameters

Name
`I`
`O`

Parameters

Name	Type
`schema`	`GrpcSchema`
`method`	`string`

Returns

GrpcMethod<I, O>

compileHttpRequest

▸ compileHttpRequest(builder): Object Lower a declaration without acquiring credentials or performing I/O.

Parameters

Name	Type
`builder`	`RequestBuilder`

Returns

Object

Name	Type
`method`	`"GET"` \| `"HEAD"` \| `"POST"` \| `"PUT"` \| `"PATCH"` \| `"DELETE"`
`route`	readonly ({ `kind`: `"key_component"` ; `subject`: `HttpInputReference` ; `index`: `number` } \| { `kind`: `"resource_segment"` ; `subject`: `HttpInputReference` ; `prefix`: readonly (HttpInput \| { kind: “literal”; value: string; })[] ; `suffix?`: `string` } \| `HttpInput` \| { `kind`: `"concat"` ; `parts`: readonly (HttpInput \| { kind: “literal”; value: string; })[] } \| { `kind`: `"literal"` ; `value`: `string` } \| { `kind`: `"resume_path"` ; `prefix`: `string` })[]
`query`	{ `[k: string]`: `T`; }
`headers`	{ `[k: string]`: `T`; }
`body?`	`HttpTemplate`
`request_schema?`	`HttpRequestSchema`
`grpc?`	`GrpcExchange`
`body_encoding?`	{ `kind`: `"protobuf"` ; `schema`: `GrpcSchema` ; `message`: `string` } \| { `kind`: `"file"` ; `content_type`: `string` ; `max_bytes`: `number` } \| { `kind`: `"raw"` ; `content_type`: `string` ; `encoding`: `"utf8"` \| `"base64url"` } \| { `kind`: `"multipart"` ; `subtype`: `"related"` \| `"form_data"` ; `parts`: readonly { `name`: `string` ; `filename?`: `string` ; `content_type`: `string` ; `encoding`: `"json"` \| `"utf8"` \| `"base64url"` \| { `file`: { `max_bytes`: `number` } } }[] }

identityFields

▸ identityFields(key): readonly string[]

Parameters

Name	Type
`key`	`IdentityKey`<`Fields`>

Returns

readonly string[]

identityContract

▸ identityContract(schema, key, path?): Extract<RecordKeySource, { kind: "field" | "compound" }> Lower through the existing native exact-key encoding and evidence checks.

Parameters

Name	Type
`schema`	`Fields`
`key`	`IdentityKey`<`Fields`>
`path`	(`field`: `string`) => readonly `string`[]

Returns

Extract<RecordKeySource, { kind: "field" | "compound" }>

encodeIdentity

▸ encodeIdentity(schema, key, read): string

Parameters

Name	Type
`schema`	`Fields`
`key`	`IdentityKey`<`Fields`>
`read`	(`field`: `string`) => `unknown`

Returns

string

defineResource

▸ defineResource<I, S, C>(input): ResourceDeclaration<NonNullable<I["_connectionSetup"]>, S, C["kind"], keyof C["setup"] & string, C["credentialKind"], CommandsOf<I>> Native transports expose an already admitted collection through the same constructor.

Type parameters

Name	Type
`I`	extends `Declaration`
`S`	extends `Fields`
`C`	extends `ConnectionDefinition`

Parameters

Name	Type
`input`	{ `integration`: `I` ; `collection`: `SourceHandle`<`S`> ; `connection`: `C` } & `ResourceOptions`<`S`>

Returns

ResourceDeclaration<NonNullable<I["_connectionSetup"]>, S, C["kind"], keyof C["setup"] & string, C["credentialKind"], CommandsOf<I>> ▸ defineResource<Setup, S, Kind, Credential, Keys, Commands>(input): ResourceDeclaration<ObjectType<Setup>, S, Kind, Keys, Credential, { readonly [K in keyof Commands]: CommandHandle<ObjectType<Commands[K][“args”]>, Commands[K][“target”]> }> One setup schema, one acquisition owner and the explicitly supported commands.

Type parameters

Name	Type
`Setup`	extends `Fields`
`S`	extends `Fields`
`Kind`	extends `string`
`Credential`	extends `string`
`Keys`	extends `Extract`<keyof `Setup`, `string`> = `never`
`Commands`	extends `Record`<`string`, `ResourceCommand`<`any`, `any`>> = {}

Parameters

Name	Type
`input`	{ `setup`: `Setup` ; `setupFields?`: `SetupDeclaration` ; `schema`: `S` ; `identity`: `ResourceIdentity`<`S`> ; `connection`: `ResourceConnection`<`Setup`, `Kind`, `Credential`, `Keys`> ; `selection?`: `Exclude`<`Extract`<keyof `Setup`, `string`>, `Keys`> ; `read`: `ResourceRead` ; `commands?`: `Commands` } & `Omit`<`ResourceOptions`<`S`>, `"selection"`>

Returns

ResourceDeclaration<ObjectType<Setup>, S, Kind, Keys, Credential, { readonly [K in keyof Commands]: CommandHandle<ObjectType<Commands[K][“args”]>, Commands[K][“target”]> }>

defineResourceGroup

▸ defineResourceGroup<I, T, C>(input): ResourceGroupDeclaration<NonNullable<I["_connectionSetup"]>, { readonly [K in string | number | symbol]: T[K] extends SourceHandle<S> ? ResourceTable<S> : never }, C["kind"], keyof C["setup"] & string, C["credentialKind"], CommandsOf<I>> One coupled acquisition and its inseparable tables.

Type parameters

Name	Type
`I`	extends `Declaration`
`T`	extends `Record`<`string`, `SourceHandle`<`any`>>
`C`	extends `ConnectionDefinition`

Parameters

Name	Type
`input`	`MultiResourceOptions`<`I`, `T`, `C`>

Returns

ResourceGroupDeclaration<NonNullable<I["_connectionSetup"]>, { readonly [K in string | number | symbol]: T[K] extends SourceHandle<S> ? ResourceTable<S> : never }, C["kind"], keyof C["setup"] & string, C["credentialKind"], CommandsOf<I>>

defineResourceBundle

▸ defineResourceBundle<I, T, C>(input): ResourceGroupDeclaration<NonNullable<I["_connectionSetup"]>, { readonly [K in string | number | symbol]: T[K] extends SourceHandle<S> ? ResourceTable<S> : never }, C["kind"], keyof C["setup"] & string, C["credentialKind"], CommandsOf<I>> Independent callback collections sharing a connection, without joint publication.

Type parameters

Name	Type
`I`	extends `Declaration`
`T`	extends `Record`<`string`, `SourceHandle`<`any`>>
`C`	extends `ConnectionDefinition`

Parameters

Name	Type
`input`	`MultiResourceOptions`<`I`, `T`, `C`>

Returns

command

▸ command<A, Target, Send, Reconcile, Sent, Reconciled, C>(definition): Omit<CommandShape<A, Target, C>, "send" | "reconcile"> & { send: (ctx: IntegrationContext<any, any>, input: InputFor<A, C>) => Promise<Sent> ; reconcile: (ctx: IntegrationContext<any, any>, input: Omit<InputFor<A, C>, "expires_at">) => Promise<Reconciled> } Semantic constructors preserve the existing native command and call owners.

Type parameters

Name	Type
`A`	extends `Fields`
`Target`	extends `string`
`Send`	extends `HttpContract`[`"response"`]
`Reconcile`	extends `HttpContract`[`"response"`]
`Sent`	extends `CommandResult`<`any`>
`Reconciled`	extends `CommandResult`<`any`>
`C`	extends `Creation` = `undefined`

Parameters

Name	Type
`definition`	`Omit`<`CommandShape`<`A`, `Target`, `C`>, `"args"` \| `"target"` \| `"send"` \| `"reconcile"`> & { `args`: `A` ; `target`: `Target` ; `creates?`: `C` ; `send`: `Exchange`<`A`, `C`, `Send`, `Sent`> ; `reconcile`: `Exchange`<`A`, `C`, `Reconcile`, `Reconciled`> }

Returns

Omit<CommandShape<A, Target, C>, "send" | "reconcile"> & { send: (ctx: IntegrationContext<any, any>, input: InputFor<A, C>) => Promise<Sent> ; reconcile: (ctx: IntegrationContext<any, any>, input: Omit<InputFor<A, C>, "expires_at">) => Promise<Reconciled> } ▸ command<A, Target, Send, Sent, C>(definition): Omit<CommandShape<A, Target, C>, "send" | "reconcile"> & { send: (ctx: IntegrationContext<any, any>, input: InputFor<A, C>) => Promise<Sent> } Semantic constructors preserve the existing native command and call owners.

Type parameters

Name	Type
`A`	extends `Fields`
`Target`	extends `string`
`Send`	extends `HttpContract`[`"response"`]
`Sent`	extends `CommandResult`<`any`>
`C`	extends `Creation` = `undefined`

Parameters

Name	Type
`definition`	`Omit`<`CommandShape`<`A`, `Target`, `C`>, `"args"` \| `"target"` \| `"send"` \| `"reconcile"` \| `"delivery"`> & { `args`: `A` ; `target`: `Target` ; `creates?`: `C` ; `delivery`: `Extract`<`CommandDefinition`<`A`, `Record`<`Target`, `Fields`>>[`"delivery"`], { `kind`: `"at_least_once"` }> ; `send`: `Exchange`<`A`, `C`, `Send`, `Sent`> ; `reconcile?`: `never` }

Returns

Omit<CommandShape<A, Target, C>, "send" | "reconcile"> & { send: (ctx: IntegrationContext<any, any>, input: InputFor<A, C>) => Promise<Sent> }

validateSetupDeclaration

▸ validateSetupDeclaration(setup): SetupDeclaration Check the declaration itself, at definition time. Everything here is a defect in the definition rather than in a supplied value, so it throws: the module never loads with a declaration the backend would refuse, and an author sees it at bijection dev rather than at the first connection.

Parameters

Name	Type
`setup`	`SetupDeclaration`

Returns

SetupDeclaration

defineCollectionRecipe

▸ defineCollectionRecipe<S, P>(name): CollectionDefinition<S, any, P> A builder’s collection before defineIntegration names it. Its schema, protocol and cadence are already the named collection’s; its read refuses, because the request it reads is named only by the key it is declared under. The options are checked here, so a malformed builder fails where it is written.

Type parameters

Name	Type
`S`	extends `Fields`
`P`	extends `SourceProtocol`

Parameters

Name	Type
`name`	(`collection`: `string`) => `CollectionRecipe`<`S`, `P`>

Returns

CollectionDefinition<S, any, P>

connectionReference

▸ connectionReference<Kind, Setup>(kind, id): ConnectionReference<Kind, Setup> Reference the connection returned by source metadata connect. Native binding admission checks its connector, setup and private credential.

Type parameters

Name	Type
`Kind`	extends `string`
`Setup`	extends `Record`<`string`, `Value`> = `Record`<`string`, `Value`>

Parameters

Name	Type
`kind`	`Kind`
`id`	`string`

Returns

ConnectionReference<Kind, Setup>

​References

​CommandGoverningDefinition

​DatasetLayout

​Type Aliases

​SourceBinding

​Type declaration

​CommandRefs

​Type parameters

​TransportCollections

​Type parameters

​HttpParameters

​Type parameters

​IntegrationContext

​Type parameters

​Type declaration

​Retention

​ResumePrefix

​SourceProtocol

​CoupledResult

​Type parameters

​TimestampWindowDiscovery

​Type declaration

​CouplingDefinition

​Type parameters

​Type declaration

​ProtocolInput

​Type parameters

​ProtocolResult

​Type parameters

​DeliveryField

​IngressAuthentication

​ListenerIngress

​Type declaration

​OccurrenceHandler

​Type declaration

​ListenerProtocol

​CollectionShape

​Type parameters

​Type declaration

​CollectionDefinition

​Type parameters

​CoupledCollectionDefinition

​Type parameters

​CommandInput

​Type parameters

​Type declaration

​CreateCommandInput

​Type parameters

​Type declaration

​CommandResult

​Type parameters

​CommandCondition

​CommandStates

​Type parameters

​Index signature

​CommandDefinition

​Type parameters

​TransportCommandDefinition

​Type parameters

​Type declaration

​SourceHandle

​Type parameters

​Type declaration

​ConnectionBudget

​BackoffRepresentation

​ConnectionBackoff

​Type declaration

​TransportIntegrationDefinition

​Type parameters

​Type declaration

​Integration

​Type parameters

​CallbackIntegrationDefinition

​Type parameters

​AccountIdentityDefinition

​Type declaration

​HttpTelemetryDefinition

​Type parameters

​Type declaration

​RequestValue

References

CommandGoverningDefinition

DatasetLayout

Type Aliases

SourceBinding

Type declaration

CommandRefs

Type parameters

TransportCollections

Type parameters

HttpParameters

Type parameters

IntegrationContext

Type parameters

Type declaration

Retention

ResumePrefix

SourceProtocol

CoupledResult

Type parameters

TimestampWindowDiscovery

Type declaration

CouplingDefinition

Type parameters

Type declaration

ProtocolInput

Type parameters

ProtocolResult

Type parameters

DeliveryField

IngressAuthentication

ListenerIngress

Type declaration

OccurrenceHandler

Type declaration

ListenerProtocol

CollectionShape

Type parameters

Type declaration

CollectionDefinition

Type parameters

CoupledCollectionDefinition

Type parameters

CommandInput

Type parameters

Type declaration

CreateCommandInput

Type parameters

Type declaration

CommandResult

Type parameters

CommandCondition

CommandStates

Type parameters

Index signature

CommandDefinition

Type parameters

TransportCommandDefinition

Type parameters

Type declaration

SourceHandle

Type parameters

Type declaration

ConnectionBudget

BackoffRepresentation

ConnectionBackoff

Type declaration

TransportIntegrationDefinition

Type parameters

Type declaration

Integration

Type parameters

CallbackIntegrationDefinition

Type parameters

AccountIdentityDefinition

Type declaration

HttpTelemetryDefinition

Type parameters

Type declaration

RequestValue