Module: sources - Bijection

Classes

Interfaces

References

Type Aliases

IntegrationAddress

Ƭ IntegrationAddress: Object

Type declaration

Name	Type
`module`	`string`
`export`	`string`

DeclaredBody

Ƭ DeclaredBody<B>: B extends { kind: "grpc" ; _message?: infer T } ? GrpcReply<T> : B extends { kind: "text" } ? string : B extends { kind: "json" | "json_schema" | "document" | "positional" ; validator: infer V } ? V extends Validator<infer T, any, any> ? T : never : B extends { kind: "json_fields" ; fields: readonly infer F[] } ? Record<F, unknown> & B extends { optional_fields: readonly infer O[] } ? Partial<Record<O, unknown>> : {} : B extends { kind: "json_batch" ; selection: { fields: readonly infer F[] } } ? Record<F, unknown>[] : null Not exported: an exported type refers to it.

Type parameters

Name
`B`

HttpResponseBody

Ƭ HttpResponseBody<C>: C extends { response: { statuses: infer S } } ? { [K in keyof S]: DeclaredBody<S[K]> }[keyof S] : never Not exported: an exported type refers to it.

Type parameters

Name
`C`

HttpOutcome

Ƭ HttpOutcome<C>: Object What one ctx.request produced. The ordinary outcome carries what the destination answered. The unresolved outcome carries the opposite fact: the host has no interpretable observation of this request and evidence is what says so — a retained detail that failed its own contract, or, for a contract whose file body streams, the attempt whose body never completed before the ceiling or the connection did. It is returned rather than thrown, so the rest of a fanout is unaffected, and the status is the one the destination really answered; nothing here invents one. headers is empty because a transfer that left no retained response left no admitted headers to cite either. The only thing an integration may do with it is record the key unresolved against this exact evidence. Publication verifies the host’s own basis for that citation, classifies it — transient or settled — and decides whether the key keeps its retry responsibility; guest code chooses none of that, and is deliberately not told which classification the host reached. The host admits the outcome for exactly two contract shapes: a singleton detail read, and one declaring a streamed file body. unresolved is not narrowed to those here because making the shape depend on the contract makes IntegrationContext invariant in its contract map, which stops a connector from sharing one reader across its declared handlers.

Type parameters

Name
`C`

Type declaration

Name	Type	Description
`unresolved?`	`true`	Present and `true` only on the unresolved outcome.
`reusable?`	`true`	Host-checked existing content; only a declared revalidation can return true.
`reason?`	`"truncated"` \| `"turn_budget"` \| `"exceeds_ceiling"`	Why a streamed file body never completed, where that is what made this outcome unresolved. Diagnostic only. The host classifies the record and decides whether the key is read again; an integration that branched on this would be choosing a retry policy it does not own.
`status`	`number`	-
`headers`	`Record`<`string`, `string`>	Empty on the unresolved outcome. A transfer that left no retained response left no admitted headers to cite either.
`body`	`HttpResponseBody`<`C`>	Absent on the unresolved outcome, as for any body this contract retains opaquely: there is nothing to read and nothing that could be read.
`evidence`	`ResponseEvidence`	-

SyncEvery

Ƭ SyncEvery: { seconds: number } | { minutes: number } | { hours: number }

CommandGoverningResult

Ƭ CommandGoverningResult: [Exclude<GoverningResult, null> & { recheckAt?: never } | null | { recheckAt: number ; validUntil?: never }] A command rule decides one command and returns a one-element list: the shared permitting results plus command-only advisory deferral. A bare value, an empty or longer list, and a rule that falls off its end refuse. recheckAt denies now and requests a future evaluation; it is never permission. Its timestamp has the same finite safe-integer epoch-millisecond, strictly future, at-most-366-day bounds as validUntil. Review, acceptance and send require a permitting result whose validity extends past the actual commit. The native decoder rejects unknown fields and mixed permit/defer objects. A rule that never defers declares returns: readAccessResults.

CommandDeliveryContract

Ƭ CommandDeliveryContract<D>: D extends { kind: string } ? Omit<D, "review"> : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	`NonNullable`<`CommandDefinition`<`Fields`, `Record`<`string`, `Fields`>>[`"delivery"`]>

CommandGoverningInput

Ƭ CommandGoverningInput: Object

Type declaration

Name	Type	Description
`condition`	`CommandCondition`	Native admitted comparison contract. The product rule must refuse a condition weaker than the business operation requires. It is retained with the exact command meaning through acceptance and recovery.
`delivery`	`CommandDeliveryContract`	Native retained deduplication and expiry assumptions. Product policy can require these independently of conditional comparison.
`phase`	`"acceptance"` \| `"send"` \| `"reconcile"`	-
`requester`	`string`	-
`target`	`CommandTarget`	-
`args`	`Value`	-
`approval`	`null`	-
`terms?`	`SourceTerms`	Present only when the integration declares installation terms.

RelationalExecutor

Ƭ RelationalExecutor<Engine>: Omit<SourceHandle, "withScope" | "resourceValidator" | "row"> & { kind: "relational" ; engine?: Engine ; execution: () => { kind: "source" ; binding: SourceBinding } } Declare retained HTTP callbacks and their source collections.

Type parameters

Name	Type
`Engine`	extends `VirtualTableEngine` \| `undefined` = `VirtualTableEngine` \| `undefined`

RetainedAccessBinding

Ƭ RetainedAccessBinding<T>: T extends AccessTableBinding<infer R, infer B> ? AccessTableBinding<R, B> : T extends PrincipalSourceTable<infer Field> ? PrincipalSourceTable<Field> : unknown Not exported: an exported type refers to it.

Type parameters

Name
`T`

AccessWriteProgram

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

Type declaration

Name	Type
`kind`	`"resource"` \| `"contract"` \| `"assignments"` \| `"roleDefinitions"` \| `"requests"`
`model`	`AccessProgram`
`contract?`	`string`

HttpProvider

Ƭ HttpProvider: Readonly<{ name: string ; authentication: { kind: "none" } | { kind: "header" ; name: string ; prefix?: string } }> Provider protocol, independent of the deployed account and credential.

ConnectionRequest

Ƭ ConnectionRequest: Object Current policy sees the actual invocation’s caller and concrete request. Source disclosure is checked independently by the native owner.

Type declaration

Name	Type
`connection`	`string`
`method`	`string`
`path`	`string`
`query`	`Record`<`string`, `string`>
`json?`	`any`

HttpEffect

Ƭ HttpEffect: Readonly<{ kind: "http" ; connection: DeploymentValue ; provider: HttpProvider ; policy: { name: string } ; method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" ; path: string ; timeoutMs: number ; maxRequestBytes: number ; maxResponseBytes: number }>

HttpConnectionRef

Ƭ HttpConnectionRef: Readonly<{ http: (options: { method: HttpEffect["method"] ; path: string ; timeoutMs?: number ; maxRequestBytes?: number ; maxResponseBytes?: number }) => HttpEffect }>

ActionEffects

Ƭ ActionEffects: Readonly<Record<string, HttpEffect>>

HttpEffectRequest

Ƭ HttpEffectRequest: Readonly<{ query?: Readonly<Record<string, string>> ; json?: unknown }>

HttpEffectResponse

Ƭ HttpEffectResponse: Readonly<{ status: number ; ok: boolean ; headers: Readonly<Record<string, string>> ; text: () => Promise<string> ; json: () => Promise<unknown> }>

EffectContext

Ƭ EffectContext<Effects>: Object

Type parameters

Name	Type
`Effects`	extends `ActionEffects`

Type declaration

Name	Type
`effects`	{ readonly [Name in keyof Effects]: Function }

ConnectionCheckSource

Ƭ ConnectionCheckSource: Object

Type declaration

Name	Type
`collection`	`string`
`source`	`string`

NativeCheckControls

Ƭ NativeCheckControls: Object

Type declaration

Name	Type
`issue`	() => `Promise`<{ `request`: `string` }>
`read`	(`request`: `string`) => `Promise`<`CheckReceipt` \| `null`>

ConnectionCheckHistoryEntry

Ƭ ConnectionCheckHistoryEntry: Object

Type declaration

Name	Type
`request`	`string`
`receipt`	`CheckReceipt` \| `null`

ApplicationConnectionChecks

Ƭ ApplicationConnectionChecks: Object

Type declaration

Name	Type
`history`	(`ctx`: `BijectionQueryCtx`<`any`, `any`>, `source`: `ConnectionCheckSource`) => `Promise`<`ConnectionCheckHistoryEntry`[]>
`request`	(`ctx`: `BijectionMutationCtx`<`any`, `any`>, `source`: `ConnectionCheckSource`, `native`: `NativeCheckControls`) => `Promise`<{ `request`: `string` }>
`complete`	(`ctx`: `BijectionMutationCtx`<`any`, `any`>, `source`: `ConnectionCheckSource` & { `request`: `string` }, `read`: `NativeCheckControls`[`"read"`]) => `Promise`<`CheckReceipt`>
`pending`	(`ctx`: `BijectionQueryCtx`<`any`, `any`>, `source`: `ConnectionCheckSource`, `read`: `NativeCheckControls`[`"read"`]) => `Promise`<`bigint` \| `null`>

Context

Ƭ Context: BijectionQueryCtx<any, any> Not exported: an exported type refers to it.

ApplicationExternalResources

Ƭ ApplicationExternalResources: Object Installed evidence owner. Callbacks retain the caller and current policy.

Type declaration

Name	Type
`catalog`	(`ctx`: `Context`, `args?`: { `root?`: `AppResourceRef` ; `direction?`: `"upstream"` \| `"downstream"` \| `"both"` }) => `Promise`<`AppExternalCatalog`>
`resolve`	(`ctx`: `Context`, `selector`: `AppExternalSelector`) => `Promise`<`AppResourceRef`>
`search`	(`ctx`: `Context`, `args`: { `prefix`: `string` ; `kind?`: `AppExternalSelector`[`"kind"`] ; `limit?`: `number` }) => `Promise`<`AppExternalSearch`>
`activity`	(`ctx`: `Context`, `resource`: `AppResourceRef`, `cursor`: `string` \| `null`) => `Promise`<`AppExternalActivity`>
`inspect`	(`ctx`: `Context`, `resource`: `AppResourceRef`) => `Promise`<`AppExternalInspection`>
`explain`	(`ctx`: `Context`, `resource`: `AppResourceRef`, `selection`: { `kind`: `"external_run"` ; `run_id`: `string` } \| { `kind`: `"lineage_observation"` ; `observation_id`: `string` }) => `Promise`<`unknown`>
`health`	(`ctx`: `Context`, `resource`: `AppResourceRef`, `args`: `Omit`<`AppHealthArgs`, `"ref"` \| `"context"`>) => `Promise`<`AppHealthAssessment`[]>
`retain`	(`ctx`: `BijectionMutationCtx`<`any`, `any`>, `args`: { `resource`: `AppResourceRef` ; `source`: `string` ; `observation_id`: `string` ; `owner`: `string` ; `is_retained`: `boolean` }) => `Promise`<`null`>
`history`	(`ctx`: `Context`, `resource`: `AppResourceRef`, `args`: `Omit`<`AppHealthArgs`, `"ref"` \| `"context"`>) => `Promise`<`AppReportedHealthHistory`[]>

BrowserAddress

Ƭ BrowserAddress: Object

Type declaration

Name	Type
`route`	`Readonly`<`WireBrowserAddress`<`HttpTemplate`>[`"route"`]>
`query?`	`WireBrowserAddress`<`HttpTemplate`>[`"query"`]

BrowserContract

Ƭ BrowserContract<R>: Object

Type parameters

Name	Type
`R`	extends `Record`<`string`, `BrowserAddress`> = `Record`<`string`, `BrowserAddress`>

Type declaration

Name	Type	Description
`reads?`	`R`	Exact additional GETs needed by the page, including scripts and styles. Omission grants none. The enclosing contract grants the semantic request.
`resources?`	readonly `BrowserResources`[]	Same-origin static resource directories relative to the connection base.
`tokens?`	`Record`<`string`, `Omit`<`BrowserToken`, `"from"`> & { `from`: keyof `R` & `string` }>	Fresh tokens bound by native custody to a supporting response. These fields cannot replace declared business arguments.
`capture`	`WireBrowserContract`<`HttpTemplate`>[`"capture"`]	A page capture returns text fields (an array with `rows`). Only the actual response to the declared request can establish a command receipt.

BrowserElement

Ƭ BrowserElement: Object

Type declaration

Name	Type
`fill`	(`value`: `string`) => `Promise`<`void`>
`click`	() => `Promise`<`void`>
`selectOption`	(`value`: `string`) => `Promise`<`void`>
`setChecked`	(`checked`: `boolean`) => `Promise`<`void`>
`waitFor`	() => `Promise`<`void`>
`innerText`	() => `Promise`<`string`>
`isVisible`	() => `Promise`<`boolean`>

BrowserPage

Ƭ BrowserPage<R>: Object

Type parameters

Name	Type
`R`	extends `string` = `string`

Type declaration

Name	Type
`goto`	(`read?`: `R`) => `Promise`<`void`>
`getByRole`	(`role`: `string`, `options`: { `name`: `string` }) => `BrowserElement`
`getByLabel`	(`text`: `string`) => `BrowserElement`
`getByTestId`	(`id`: `string`) => `BrowserElement`
`locator`	(`selector`: `string`) => `BrowserElement`

BrowserImplementation

Ƭ BrowserImplementation<I, R>: BrowserContract<R> & { run: (page: BrowserPage<keyof R & string>, input: I) => Promise<void> }

Type parameters

Name	Type
`I`	`unknown`
`R`	extends `Record`<`string`, `BrowserAddress`> = `Record`<`string`, `BrowserAddress`>

BrowserProtocol

Ƭ BrowserProtocol: typeof browserProtocols[BrowserConfinement]

BrowserResourceReference

Ƭ BrowserResourceReference<Setup, Confinement>: ResourceReference<Setup, "browser", keyof Setup & string, "http"> & { _browser: Confinement }

Type parameters

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

BrowserSessionRequest

Ƭ BrowserSessionRequest: Object

Type declaration

Name	Type
`request_key`	`string`
`purpose`	`"request"` \| `"authorization"`
`timeout_ms`	`number`

BrowserSession

Ƭ BrowserSession: Object A handoff contains custody identities only. Neither a CDP URL nor a bearer crosses a component API.

Type declaration

Name	Type
`lease`	`string`
`delivery_ref`	`string`

BrowserSessionStatus

Ƭ BrowserSessionStatus: Object

Type declaration

Name	Type
`state`	`"allocating"` \| `"ready"` \| `"releasing"` \| `"released"` \| `"attention"`
`delivery_ref`	`string`
`expires_at`	`number`
`resource_id`	`string` \| `null`
`provider_binding`	`string` \| `null`
`provider_owner`	{ `installation`: `string` ; `record`: `string` }
`provider_owner.installation`	`string`
`provider_owner.record`	`string`
`exchange_receipt`	`string` \| `null`

Reference

Ƭ Reference<Kind, Args, Result>: FunctionReference<Kind, "public" | "internal", Args, Result> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Kind`	extends `"query"` \| `"mutation"`
`Args`	extends `Record`<`string`, `Value`>
`Result`	`Result`

BrowserProviderApi

Ƭ BrowserProviderApi: Object

Type declaration

Name	Type
`acquire`	`Reference`<`"mutation"`, `BrowserSessionRequest`, `BrowserSession`>
`inspect`	`Reference`<`"query"`, { `lease`: `string` }, `BrowserSessionStatus`>
`release`	`Reference`<`"mutation"`, { `lease`: `string` }, `null`>

VirtualTableEngine

ConnectionIntegration

Ƭ ConnectionIntegration: { module: string ; export: string ; label?: string } | IntegrationReference<any> | { isIntegration: true ; exportIntegration: () => string }

ConnectedMcpRequest

Ƭ ConnectedMcpRequest: Readonly<{ method: "POST" | "DELETE" ; headers: Readonly<Record<string, string>> ; body: string | null }> One Streamable HTTP exchange with an MCP server: the request an MCP client sends, without its address or credential.

ConnectedMcpResponse

Ƭ ConnectedMcpResponse: Readonly<{ status: number ; headers: Readonly<Record<string, string>> ; body: string }> The server’s result: its status, its content-type and mcp-session-id headers and its body.

IntegrationReference

Ƭ IntegrationReference<Setup>: Object A generated reference to an integration and its connection input.

Type parameters

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

Type declaration

Name	Type
`_type`	`"integration"`
`_setup`	`Setup`

SetupSupplier

Ƭ SetupSupplier: "administrator" | "account" Who is holding the answer. administrator is deployment configuration: the person who deployed this definition knows it, it is the same for every connection they make, and it may be recorded. account is the connecting customer’s own: their instance, their region, their workspace. The distinction is not cosmetic — it decides who is asked, what may be retained and, for a value that reaches a URL, how far it is allowed to move.

SetupSlot

Ƭ SetupSlot: "base_url" The one slot a setup value may fill beyond being recorded. A value that fills base_url is rendered as prefix + value + suffix and becomes the connection’s base URL. That is the ONLY way a supplied value reaches an address, and it is why the rendering is a template the definition wrote rather than a string the supplier wrote: the supplier contributes one host label inside an address they did not choose, and the result still has to pass the deployment’s ordinary base-URL confinement before any request is built from it.

SetupValidation

Ƭ SetupValidation: Object What an admitted value has to look like. pattern is matched against the WHOLE value; there is no need to anchor it and no way to leave it unanchored. It is restricted to the constructs Rust’s regular expressions and JavaScript’s agree on, because the same pattern is compiled on both sides and a pattern that means two things is worse than no pattern at all: lookaround and backreferences are refused at definition time.

Type declaration

Name	Type	Description
`pattern?`	`string`	-
`allowed?`	readonly `string`[]	The complete set of admitted values, for a choice rather than a format.
`minLength?`	`number`	-
`maxLength?`	`number`	-

SetupField

Ƭ SetupField: SetupValidation & { key: string ; supplier: SetupSupplier ; label: string ; help?: string ; docUrl?: string ; example?: string ; prefix?: string ; suffix?: string ; secret?: boolean ; optional?: boolean ; derivable?: boolean ; fills?: SetupSlot } One thing a connection has to be told.

SetupDeclaration

Ƭ SetupDeclaration: readonly SetupField[] The declaration as it is written on an integration definition.

SetupRefusal

Ƭ SetupRefusal: { kind: "unknown_field" ; key: string } | { kind: "missing_required" ; key: string } | { kind: "pattern_mismatch" ; key: string } | { kind: "not_allowed" ; key: string } | { kind: "too_short" ; key: string ; minLength: number } | { kind: "too_long" ; key: string ; maxLength: number } | { kind: "secret_not_accepted" ; key: string } | { kind: "slot_not_one_label" ; key: string } | { kind: "not_account_supplied" ; key: string } Why one supplied value was refused. Exhaustive and typed on both sides of the boundary: the same variants are a Rust enum the backend matches on, so a new kind of refusal is a compile error rather than a new string nobody renders.

SetupRequirement

Ƭ SetupRequirement: SetupField & { configured: boolean } What the deployment says about one declared field when asked what a connection still needs. It carries the declaration and ONE fact about the deployment: whether the value is already held. It never carries a value — not a secret, and not a recorded administrator value either, because a reader that does not need it to fill a form does not need it at all.

EwsMailbox

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

Type declaration

Name	Type
`transport`	`"mailbox"`
`value`	{ `provider`: `"ews"` }
`value.provider`	`"ews"`

NativeSetupFor

Ƭ NativeSetupFor<T>: T extends EwsMailbox ? typeof ewsConnectionSetup : T extends { kind: infer K } ? typeof nativeConnectionSchemas[K] : T extends { transport: infer K } ? typeof nativeConnectionSchemas[K] : {} & T extends { kind: "kafka" | "mqtt" | "pubsub" ; correlation: string } ? { commandTopic: ReturnType<typeof string> } : {} Not exported: an exported type refers to it.

Type parameters

Name
`T`

ResourceTable

Ƭ ResourceTable<S, Scope, Contract>: Object An explicit resource output. Source handles stay inside compiler lowering.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `GenericValidator`> = `Record`<`string`, `GenericValidator`>
`Scope`	extends `Record`<`string`, `Value`> = {}
`Contract`	`string` extends keyof `S` ? `any` : `ObjectType`<`S`>

Type declaration

Name	Type	Description
`schema`	`S`	-
`row`	`SourceHandle`<`S`, `Scope`, `Contract`>[`"row"`]	-
`__resourceContract?`	`Contract`	Preserve the connector contract when a table infers its source type.
`__scopeType?`	`Scope`	-
`[member]`	`SourceHandle`<`S`, `Scope`, `Contract`>	-
`resourceValidator`	`SourceHandle`<`S`, `Scope`, `Contract`>[`"resourceValidator"`]	-
`withScope`	<ScopeFields>(`fields`: `ScopeFields`) => `ResourceTable`<`S` & `ScopeFields`, `ObjectType`<`ScopeFields`>, `Contract`>	Bind this output to immutable application references at installation.

CallPublication

Ƭ CallPublication: "unavailable" | "pending" | "blocked" | "published" | "cancelled" Remaining local admission of a retained response, independent of delivery.

BrowserLocator

Ƭ BrowserLocator: { kind: "role" ; role: string ; name: string } | { kind: "label" ; text: string } | { kind: "test_id" ; id: string } | { kind: "css" ; selector: string }

BrowserResources

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

Type declaration

Name	Type
`route`	`string`[]

BrowserToken

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

Type declaration

Name	Type
`from`	`string`
`header`	`string`

BrowserCapture

Ƭ BrowserCapture: { kind: "response" } | { kind: "page" ; fields: Record<string, BrowserLocator> ; rows?: BrowserLocator ; empty?: BrowserLocator }

BrowserDiagnostics

Ƭ BrowserDiagnostics: Object

Type declaration

Name	Type	Description
`session`	`BrowserSessionReference` \| `null`	-
`scope`	`BrowserScopeFailure` \| `null`	-
`phase`	`BrowserPhase`	-
`failure`	`BrowserFailure` \| `null`	-
`duration_us`	`number`	`Native Integer` signed
`startup_us`	`number` \| `null`	Time to the worker’s first command request; absent if it never arrived.
`requests`	`number`	`Native Integer` signed
`response_bytes`	`number`	`Native Integer` signed
`worker_completed`	`boolean`	-
`commands`	`BrowserCommandObservation`[]	-

BrowserSessionReference

Ƭ BrowserSessionReference: Object Opaque links into existing component and native call custody. No provider URL.

Type declaration

Name	Type	Description
`component`	`string`	-
`lease`	`string`	-
`delivery_ref`	`string`	-
`confinement`	`BrowserConfinement`	Under `unenforced`, a scope denial or a missing primary exchange does not establish that the browser sent nothing.

BrowserConfinement

Ƭ BrowserConfinement: "enforced" | "unenforced" Whether physical isolation enforces that every page request crosses the native broker. An Unenforced provider still routes page requests through the broker, but nothing beneath the browser prevents traffic that bypasses it, so the absence of a brokered request no longer proves nothing was sent.

BrowserScopeFailure

Ƭ BrowserScopeFailure: Object

Type declaration

Name	Type	Description
`expected_method`	`string`	-
`observed_method`	`string`	-
`primary_started`	`boolean`	Native dispatch had begun before this denial. Its absence proves no primary send only under enforced confinement.

BrowserPhase

Ƭ BrowserPhase: "starting" | "running" | "complete" | "failed" Not exported: an exported type refers to it.

BrowserFailure

BrowserCommandObservation

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

Type declaration

Name	Type
`command`	`BrowserCommandName`
`duration_us`	`number`
`completed`	`boolean`
`location`	`BrowserLocation` \| `null`

BrowserCommandName

BrowserLocation

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

Type declaration

Name	Type
`file`	`string`
`line`	`number`
`column`	`number`

ComputeJobReference

Ƭ ComputeJobReference: Object A job-only function’s reference says how it runs. No value holds this property; it keeps the execution contract in the type, so hovering a generated reference shows it and direct calls refuse it during development.

Type declaration

Name	Type
`_requiresComputeJob`	`"Start this function as a durable run or through Workflow or Pipelines."`

RetainedInterfaceMembership

Ƭ RetainedInterfaceMembership<T>: T extends { [interfaceMembership]: infer M } ? { [interfaceMembership]: M } : unknown & T extends { [interfaceNavigationMappings]: infer M } ? InterfaceNavigationIdentity<M> : unknown & T extends { [interfaceWritableMappings]: infer M } ? { [interfaceWritableMappings]: M } : unknown Not exported: an exported type refers to it.

Type parameters

Name
`T`

ProviderInputRef

Ƭ ProviderInputRef: Readonly<{ source: string ; occurrence: string ; digest: string }> Original native byte identity. Possession grants no access.

ProviderInputInspection

Ƭ ProviderInputInspection: Readonly<{ input: ProviderInputRef ; owner: { installation: string ; record: string } | null ; acceptedAt: number ; eventType: string | null ; expiresAt: number ; ready: boolean ; files: readonly { part: string ; file: FileRef ; sha256: string ; size: number ; contentType: string }[] }>

ProviderInputFileGrant

Ƭ ProviderInputFileGrant: Readonly<{ input: ProviderInputRef ; part: string ; key: string ; file: FileRef ; sha256: string ; size_bytes: number ; content_type: string ; grant: string ; expires_at: number }> Exact native content admitted to a child workload. This receipt contains no delivery credential and does not extend the original input’s lifetime.

ProviderInputFile

Ƭ ProviderInputFile: Readonly<{ input: ProviderInputRef ; owner: { installation: string ; record: string } ; source_expires_at: number ; part: string ; file: FileRef ; sha256: string ; size_bytes: number ; content_type: string }> Exact inspected input part. File identifiers and owner coordinates carry identity only; native grants remain the authority to release bytes.

CaseName

Ƭ CaseName: typeof providerJourneyCases[number] Not exported: an exported type refers to it.

CaseReference

Ƭ CaseReference: FunctionReference<"action", "internal", { fixture: string ; runId: string }, typeof type> Not exported: an exported type refers to it.

ProviderCustodyErrorData

Ƭ ProviderCustodyErrorData: Object A local custody fence. It never proves an earlier remote outcome.

Type declaration

Name	Type
`kind`	`"provider_custody_error"`
`code`	`"ProviderCustodyRestored"`

ProviderDeliveryPolicy

Ƭ ProviderDeliveryPolicy: Readonly<{ reconcilable: boolean ; sendUntil: number ; inspectUntil: number ; maxAttempts: number ; attemptMs: number }> Native physical bounds of one captured command. They fence every attempt; the delivery component’s protocol chooses how to spend them.

ProviderCommandOrdering

Ƭ ProviderCommandOrdering: Readonly<{ domain: string ; mode: "exclusive" | "shared" | "latest" }> Facts the delivery component orders a live command by: the native verified target key and the connector’s declared ordering mode. Native custody does not order provider commands.

ProviderExchangeSettlement

Ƭ ProviderExchangeSettlement: "settled" | "unsettled" | "unbounded"

ProviderRefusal

Ƭ ProviderRefusal: Readonly<{ kind: "precondition_failed" | "member_missing" | "invariant_violated" | "malformed" | "identity_reused" ; name: string ; member: number | null ; current?: Value }>

ProviderObservation

Ƭ ProviderObservation: { settlement: ProviderExchangeSettlement ; exchangeClosed: boolean ; diagnostic: { code: "IntegrationSourceUnsupported" ; message: string } | null ; interpretation?: { revision: string ; response: string ; requestId: string ; authorizedAtMs: number } } & { kind: "applied" | "not_dispatched" | "not_applied" ; receipt: string } | { kind: "contract_mismatch" ; receipt: string } | { kind: "refused" ; receipt: string ; refusal: ProviderRefusal | null } | { kind: "duplicated" ; count: number ; receipt: string } | { kind: "pending" ; receipt: string ; retryAfterMs: number | null } | { kind: "progress" ; receipt: string ; ordinal: number } | { kind: "unknown" ; receipt: string | null }

ProviderResultArtifact

Ƭ ProviderResultArtifact: Readonly<{ file: string ; sha256: string ; bytes: number ; programDigest: string ; inputDigest: string ; definition: string ; command: ProviderCommandResultContract | null }>

ProviderCommandResultContract

Ƭ ProviderCommandResultContract: Readonly<{ component: string | null ; integration: { module: string ; export: string } ; command: string ; path: readonly string[] ; validator: ValidatorJSON }>

PublishedSourceRecord

Ƭ PublishedSourceRecord: { component: string | null ; table: string ; id: string } | { sourceId: SourceId ; key: string ; entity: string | null }

ProviderPublication

Ƭ ProviderPublication: Object

Type declaration

Name	Type
`kind`	`"complete"` \| `"pending"`
`processResult`	`ProviderResultArtifact` \| `null`
`commandResult`	`ProviderResultArtifact` \| `null`
`record`	`PublishedSourceRecord` \| `null`

ProviderStateEvidence

Ƭ ProviderStateEvidence: { kind: "unstated" } | { kind: "unavailable" ; reason: string } | { kind: "observed" ; expected: Record<string, Value> ; actual: Record<string, Value> ; record: { component: string | null ; table: string ; id: string } ; source: string ; incarnation: string ; revision: string } Readonly current Source facts from one exact original physical intention. The delivery component owns comparison; these facts never prove delivery.

ProviderSourceEffect

Ƭ ProviderSourceEffect: { kind: "pending" ; reason: string } | { kind: "unsupported" ; reason: string } | { kind: "incorporated" ; source: string ; incarnation: string ; record: PublishedSourceRecord ; representations?: { component: string | null ; dataset: string ; contract: string ; version: string ; checkpoint: string ; publisherGeneration: string }[] ; revision: string ; basis: { kind: "position" ; required: { space: string ; value: string } ; current: { space: string ; value: string } } | { kind: "effect" | "observation" ; command: string ; capture: string ; digest: string ; corroborating?: string | null } } A current native read incorporating an authentic effect or command observation. This is read-basis evidence, not a durable grant or population checkpoint.

ProviderExecutionControl

Ƭ ProviderExecutionControl: Readonly<{ hasCancellation: boolean ; termination: "stopped" | "unknown" ; fileUploadStopped?: boolean }>

ModeledProviderConsequence

Ƭ ModeledProviderConsequence: { kind: "modeled" ; capture: string } | { kind: "unavailable" ; reason: string } | { kind: "refused" ; capture: string ; reason: string }

ProviderDeliveryStatus

Ƭ ProviderDeliveryStatus: Readonly<{ operation: string ; custody: "pending" | "held" | "unknown" | "settled" | "withdrawn" ; evidence: "applied" | "duplicated" | "not_applied" | "refused" | null ; refusal: string | null ; generation: number ; publication: "none" | "pending" | "blocked" | "published" | "cancelled" ; interpretation: "mismatch" | "authorized" | null }> Native custody facts for one provider command call: physical custody and the authentic observation that settled it. The delivery component decides what the command means.

ObservationHandle

Ƭ ObservationHandle<S, Kind, Contract>: Object A typed observation reference. A selection creates a pure consumer; it grants neither source evidence nor permission to execute an acquisition.

Type parameters

Name	Type
`S`	extends `Fields`
`Kind`	extends `"records"` \| `"occurrences"` \| `"artifacts"`
`Contract`	`ObjectType`<`S`>

Type declaration

Name	Type
`kind`	`Kind`
`schema`	`S`
`[observationDeclaration]`	{ `name`: `string` ; `select`: (`selection`: `RepresentationSelection`) => `SourceHandle`<`S`, {}, `Contract`> }
`[observationDeclaration].name`	`string`
`[observationDeclaration].select`	[object Object]

OccurrenceExpressions

Ƭ OccurrenceExpressions<S>: FilterBuilder<{ document: ObjectType<S> ; fieldPaths: DocumentFieldPaths<ObjectType<S>> ; indexes: {} ; searchIndexes: {} ; vectorIndexes: {} }> Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Fields`

LatestSelection

Ƭ LatestSelection<S, Output>: Object Not exported: an exported type refers to it.

Type parameters

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

Type declaration

Name	Type
`name`	`string`
`key`	readonly keyof `S` & keyof `Output` & `string`[]
`orderBy`	readonly keyof `S` & `string`[]
`publishEvery`	`SyncEvery`
`map?`	(`q`: `OccurrenceExpressions`<`S`>) => `Partial`<{ [K in keyof Output]: ExpressionOrValue<ObjectType<Output>[K & keyof ObjectType<Output>]> }>
`removeIf?`	(`q`: `OccurrenceExpressions`<`S`>) => `ExpressionOrValue`<`boolean`>

VersionRetention

Ƭ VersionRetention: { days: number } | { hours: number } | { minutes: number } Retention of immutable acquired file versions, at most one year.

SchemaOf

Ƭ SchemaOf<H>: H extends ObservationHandle<infer S, any, any> ? S : never Not exported: an exported type refers to it.

Type parameters

Name
`H`

ContractOf

Ƭ ContractOf<H>: H extends ObservationHandle<any, any, infer C> ? C : never Not exported: an exported type refers to it.

Type parameters

Name
`H`

Q

Ƭ Q: Omit<GenericQueryCtx<GenericDataModel>, "db"> Not exported: an exported type refers to it.

M

Ƭ M: BijectionMutationCtx<GenericDataModel> Not exported: an exported type refers to it.

StorageTable

Ƭ StorageTable: TableDefinition<any, any, any, any, false, any> Not exported: an exported type refers to it.

LocalStorage

Ƭ LocalStorage<T>: T extends { publishedFrom: string } | { seriesBinding: () => unknown } ? never : T Not exported: an exported type refers to it.

Type parameters

Name
`T`

HostSourceFields

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

Type declaration

Name	Type
`_sourceId`	`SourceId`
`_sourceEntity`	`string`
`_sourceBasis`	`string`

HostSourceFieldValidators

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

Type declaration

Name	Type
`_sourceEntity`	`VString`
`_sourceBasis`	`VString`
`_sourceId`	`VIdentity`<`SourceId`, `"sourceId"`, `"required"`>

SourceDocumentType

Ƭ SourceDocumentType<D>: D extends VObject<infer Type, infer Fields, infer IsOptional, any> ? VObject<Expand<Type & HostSourceFields>, Expand<Fields & HostSourceFieldValidators>, IsOptional> : D Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `Validator`<`any`, `any`, `any`>

GoverningDefinition

Ƭ GoverningDefinition<Document>: FunctionReference<"query", "public" | "internal", { changes: TableChange<Document>[] }, ReadAccessResults> | { query?: FunctionReference<"query", "public" | "internal", { changes: TableChange<Document>[] }, ReadAccessResults> ; reads?: readonly string[] | () => readonly string[] ; basis?: "original" | "final" ; appliesDelegation?: boolean ; [accessWriteProgram]?: AccessWriteProgram } Not exported: an exported type refers to it.

Type parameters

Name	Type
`Document`	extends `Object`

SourceFileArtifact

Ƭ SourceFileArtifact: Object

Type declaration

Name	Type	Description
`file`	`FileRef`	-
`sha256`	`string`	-
`size`	`number`	-
`format`	`string`	-
`sourceEpoch`	`string`	-
`sourceEvidence`	`string` \| `null`	Bounded canonical source metadata, read by the installed source owner.

Contracts

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

Type declaration

Name	Type
`SourceInspection`	`SourceInspection`
`SourcePopulationPublication`	`SourcePopulationPublication`
`AcceptedSourcePopulation`	`AcceptedSourcePopulation`
`SourceWorkStatus`	`SourceWorkStatus`
`SourceCapacityStatus`	`SourceCapacityStatus`
`SourceUpdateState`	`SourceUpdateState`
`SourceRefresh`	`SourceRefresh`
`SourceAcquisitionSelection`	`SourceAcquisitionSelection`
`SourceRebuildStatus`	`SourceRebuildStatus`
`SourceRebuildInput`	`SourceRebuildInput`
`SourceCoverageStatus`	`SourceCoverageStatus`
`SourceCoverageKind`	`SourceCoverageKind`
`SourceDatasetReader`	`SourceDatasetReader`
`SourceCapabilities`	`SourceCapabilities`
`SourceReadProtocol`	`SourceReadProtocol`
`SourceConsistency`	`SourceConsistency`
`SourceAtomicity`	`SourceAtomicity`
`SourceHistoryKind`	`SourceHistoryKind`
`EvidenceClass`	`EvidenceClass`
`SourceProfile`	`SourceProfile`
`SourceMovement`	`SourceMovement`
`ResponseMovement`	`ResponseMovement`
`BodyPlacement`	`BodyPlacement`
`BodyInterpretation`	`BodyInterpretation`
`PlanStep`	`PlanStep`
`MovementStep`	`MovementStep`
`RepresentationReason`	`RepresentationReason`
`MovementRelease`	`MovementRelease`
`InterpretedOutput`	`InterpretedOutput`
`PublicationVisibility`	`PublicationVisibility`
`ProviderReach`	`ProviderReach`
`InitialAcquisition`	`InitialAcquisition`
`ChangeAcquisition`	`ChangeAcquisition`
`DeletionAcquisition`	`DeletionAcquisition`
`AcquisitionResume`	`AcquisitionResume`
`AcquisitionGap`	`AcquisitionGap`
`SourceCommandProfile`	`SourceCommandProfile`
`SourceCommandDelivery`	`SourceCommandDelivery`
`SourceCommandCondition`	`SourceCommandCondition`
`SourceQualification`	`SourceQualification`
`ReportQualificationInspection`	`ReportQualificationInspection`
`ReportQualificationSubject`	`ReportQualificationSubject`
`ReportQualificationLedger`	`ReportQualificationLedger`
`ReportQualificationPolicy`	`ReportQualificationPolicy`
`QualificationCaseRequirement`	`QualificationCaseRequirement`
`QualificationEvidenceKind`	`QualificationEvidenceKind`
`AttestedReportQualification`	`AttestedReportQualification`
`ReportQualificationReceipt`	`ReportQualificationReceipt`
`ReportQualificationCase`	`ReportQualificationCase`
`QualificationOutcome`	`QualificationOutcome`
`ReportCapabilityQualification`	`ReportCapabilityQualification`
`SourcePreparation`	`SourcePreparation`
`SourcePreparationPhase`	`SourcePreparationPhase`
`SourceDocumentProgress`	`SourceDocumentProgress`
`SourceReportProgress`	`SourceReportProgress`
`SourceProviderJob`	`SourceProviderJob`
`SourceJobPhase`	`SourceJobPhase`
`SourceJobInventory`	`SourceJobInventory`
`SourceDownloadStatus`	`SourceDownloadStatus`
`SourceReplicationStatus`	`SourceReplicationStatus`
`SourceCapacityResource`	`SourceCapacityResource`
`SourceReplicationUnit`	`SourceReplicationUnit`
`SourceReplicationCursor`	`SourceReplicationCursor`
`SourceReplicationStaging`	`SourceReplicationStaging`
`SourceReplicationStage`	`SourceReplicationStage`
`SourceFailure`	`SourceFailure`
`SourceCause`	`SourceCause`
`ResponseCheck`	`ResponseCheck`
`ResponseProblem`	`ResponseProblem`
`ResponseIssue`	`ResponseIssue`
`SourceRecoveryFacts`	`SourceRecoveryFacts`
`SourceRetention`	`SourceRetention`
`RetainedAcquisition`	`RetainedAcquisition`
`RetentionObligation`	`RetentionObligation`
`AcquisitionPin`	`AcquisitionPin`
`SourceSelection`	`SourceSelection`
`SourceWaitReason`	`SourceWaitReason`
`IntegrationFailureReason`	`IntegrationFailureReason`
`SourceWakeDependency`	`SourceWakeDependency`
`SourceRefusalReason`	`SourceRefusalReason`
`ReportQualificationUpdate`	`ReportQualificationUpdate`
`CheckReceipt`	`CheckReceipt`
`CheckReceiptState`	`CheckReceiptState`
`SourceRebuildPreview`	`SourceRebuildPreview`
`SourceAcquisitionWindow`	`SourceAcquisitionWindow`
`SourceAcquisitionRun`	`SourceAcquisitionRun`
`SyncOrigin`	`SyncOrigin`
`SyncRunState`	`SyncRunState`
`ConnectionPage`	`ConnectionPage`
`ConnectionStatus`	`ConnectionStatus`
`ConnectionRoute`	`ConnectionRoute`
`ConnectionRouteKind`	`ConnectionRouteKind`
`ConnectionRouteTarget`	`ConnectionRouteTarget`
`ConnectionRouteFact`	`ConnectionRouteFact`
`ConnectionRepairReceipt`	`ConnectionRepairReceipt`
`ConnectionRepairState`	`ConnectionRepairState`
`SourceControlReceipt`	`SourceControlReceipt`
`SourceControlOutcome`	`SourceControlOutcome`
`SourceControlUnchanged`	`SourceControlUnchanged`
`SourceControlReply`	`SourceControlReply`
`SourceControlRequest`	`SourceControlRequest`
`SourceControlAction`	`SourceControlAction`
`SourceCapacity`	`SourceCapacity`
`SourceRequestSelector`	`SourceRequestSelector`
`SourceRequestStatus`	`SourceRequestStatus`
`SourceRequestPhase`	`SourceRequestPhase`
`SourceRequestIssue`	`SourceRequestIssue`
`SourceRequirements`	`SourceRequirements`
`SourceEvidence`	`Contract.SourceEvidence`
`ServingSourcePublication`	`ServingSourcePublication`
`SourceCheckpoint`	`SourceCheckpoint`
`SourcePosition`	`SourcePosition`
`SourceDatasetEvidence`	`SourceDatasetEvidence`
`SourceStatus`	`Contract.SourceStatus`
`SourceSync`	`Contract.SourceSync`
`SourceSyncStatus`	`SourceSyncStatus`
`SourceControls`	`SourceControls`
`SourceRequirementAssessment`	`SourceRequirementAssessment`
`SourceReadyAction`	`SourceReadyAction`
`SourceUnsupportedCode`	`Contract.SourceUnsupportedCode`
`SourceUnsupportedAction`	`SourceUnsupportedAction`
`SourceMissingEvidenceCode`	`Contract.SourceMissingEvidenceCode`
`SourceEvidenceAction`	`SourceEvidenceAction`
`SourcePopulationLayout`	`SourcePopulationLayout`
`SourcePopulationMember`	`SourcePopulationMember`
`SourceRecordRecovery`	`SourceRecordRecovery`
`SourceRecoveryKind`	`SourceRecoveryKind`

Fields

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

SourceEvidence

Ƭ SourceEvidence: SourceStatus["evidence"] What the engine can prove about one installed source’s population. Every field is derived from the evidence the capture and acquisition owners already record for that source alone. There is no credential, destination name or provider identifier here, and a value read for one source discloses nothing about another.

SourceCause

Ƭ SourceCause: NonNullable<NonNullable<SourceStatus["sync"]>["cause"]>

SourceSync

Ƭ SourceSync: NonNullable<SourceStatus["sync"]> What acquisition of one installed source is doing now. This is a different fact from SourceEvidence: an idle source can be stale or never acquired, and a held one can still serve a complete publication, so read both to say “last checked 3 minutes ago, updates blocked”.

SourceTableName

Ƭ SourceTableName<DataModel>: SourceTableNames<DataModel> & TableNamesInDataModel<DataModel> Not exported: an exported type refers to it.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

SourceSelector

Ƭ SourceSelector<DataModel, Resource>: TableSourceSelector<DataModel> | { sourceId: SourceId ; table?: never ; scope?: never ; resource?: never } | ResourceSourceSelector<Resource> The one selection every ctx.sources method takes:

{ table }: the one source of a table without application scope;
{ table, scope }: the source installed for that complete scope;
{ table, sourceId }: that source, checked to publish into the table;
{ sourceId }: a source handle, such as a row’s _sourceId;
{ resource, collection? }: a declared resource’s source.

Discovering a table’s one source requires whole-table read access, even when it has no rows; a handle requires access to that source’s rows. No selection grants control authority.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel` = `GenericDataModel`
`Resource`	extends `ResourceReference`<`any`, `any`, `any`, `any`, `any`> = `ResourceReference`<`any`, `any`, `any`, `any`, `any`>

TableSourceSelector

Ƭ TableSourceSelector<DataModel, TableName>: { [T in TableName]: Object & TableSourceSelection<NamedTableInfo<DataModel, T>> }[TableName] A SourceSelector naming one of this component’s tables.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel` = `GenericDataModel`
`TableName`	extends `SourceTableName`<`DataModel`> = `SourceTableName`<`DataModel`>

ResourceSourceSelector

Ƭ ResourceSourceSelector<Resource>: Object Select a declared resource’s installed source: its one table, or the named collection of a resource group. A sourceId must belong to it.

Type parameters

Name	Type
`Resource`	extends `ResourceReference`<`any`, `any`, `any`, `any`, `any`> = `ResourceReference`<`any`, `any`, `any`, `any`, `any`>

Type declaration

Name	Type
`resource`	`Resource`
`collection?`	`NoInfer`<`Resource`> extends { `_collections`: infer Name } ? `Name` : `never`
`sourceId?`	`SourceId`
`table?`	`never`
`scope?`	`never`

SourceContract

Ƭ SourceContract<DataModel, TableName>: NamedTableInfo<DataModel, TableName> extends { sourceContract: infer Contract } ? Contract : any Not exported: an exported type refers to it.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`TableName`	extends `TableNamesInDataModel`<`DataModel`>

InstallationScope

Ƭ InstallationScope<Scope>: Scope extends Record<string, never> ? { scope?: never } : { scope: Scope } Not exported: an exported type refers to it.

Type parameters

Name
`Scope`

SourceReadRequirement

Ƭ SourceReadRequirement: Object Evidence a read of a source-owned table requires. Declared once on the binding, defineSyncedTable({source: handle, ...{ read: requirement }}), it applies to every query and mutation read of the table: queries, pagination, point reads and subscriptions. The required sources are fixed before any row is read: every source installed under the binding, or the one an index range selects with .eq("_sourceId", ...). A source with no rows therefore still counts, and an unestablished source refuses instead of reading as empty. A read may tighten it with ctx.db.query(table).require(...); repeated requirements combine, and nothing a read chooses waives the binding’s declared floor. A refusal names the table and the unmet requirement, never a source; read ctx.sources.status to show which source is behind. A mutation that catches the refusal still cannot commit. A view, join or total over the table owes the same floor, and a read’s own .require(...) of the view adds to every source-owned relation it reads. A diagnostic screen can use ctx.sources.status to show unmet requirements while row reads retain the floor.

Type declaration

Name	Type	Description
`population?`	`"complete"` \| `"observed"`	Require complete evidence for each source’s declared external scope. A synced table defaults to complete; observed explicitly selects known records. A query that omits this field inherits the table’s requirement. A live or filtered listing cannot establish an external population.
`consistency?`	`"sourceSnapshot"`	Values must coexist at a qualified cut of each source. Supported by transactional feeds and qualified snapshots. Independent source cuts do not imply one common external instant across sources.
`version?`	`"complete"`	Require a coherent complete version of each required dataset source. A complete served version remains valid while its successor prepares.
`continuity?`	`"complete"`	Require uninterrupted native acquisition from its admitted baseline. This does not establish complete population or retained replay.
`maxObservationAge?`	`ReadDuration`	Maximum age of each required source’s population evidence. The engine enforces the resulting expiry at read release and local commit. A complete population read that states none accepts evidence at most three of the source’s acquisition intervals old, or five minutes if longer.
`stale?`	`"allowed"`	Waive the default observation age, so a complete population is served however long ago it was last observed. Only a synced table’s `read` declaration accepts it; a query’s `.require(...)` cannot weaken it.
`evidence?`	`EvidenceClass`	The weakest evidence class this read accepts. `native`: Bijection’s code made the provider request. `brokered`: Bijection saw it through the egress broker. `asserted`: a runner states it, as the dataset reader does. A read that declares none accepts only `native`; a stated class can tighten a table’s declaration but never weaken it.

SourceStatus

Ƭ SourceStatus: SourceStatus Published evidence and update work at one query basis.

SourceChangePage

Ƭ SourceChangePage: { kind: "page" ; entries: { position: string ; record: string ; version: string | null }[] ; isDone: boolean ; scannedThrough?: string } | { kind: "expired" ; retainedFrom: string } Read the coverage and freshness of an installed source. A source is named by the opaque handle the engine stamps on every row it publishes (_sourceId), and coverage is disclosed under exactly the authority those rows are: a caller a relation’s read rule refuses for a source’s rows is refused here for the same reason. The read participates in dependency tracking like any other, so a result that concluded “we cannot establish this” is reevaluated when the source’s coverage changes.

SourceBarrier

Ƭ SourceBarrier: { kind: "none" | "eachLatest" | "completeVersions" } | { kind: "publication" ; publicationId: SourcePublicationId } | { kind: "common" ; at: { kind: "revision" ; revision: string } | { kind: "publicationOf" ; sourceId: SourceId } } A requirement over source publications, evaluated on this transaction’s basis.

SourceBarrierBasis

Ƭ SourceBarrierBasis: Object

Type declaration

Name	Type
`declared`	`SourceBarrier`
`sources`	{ `sourceId`: `SourceId` ; `scope`: `string` ; `publishedAt`: `string` \| `null` ; `completeVersion`: `string` \| `null` ; `publicationId`: `SourcePublicationId` \| `null` }[]
`outcome`	{ `kind`: `"satisfied"` ; `common`: `string` \| `null` } \| { `kind`: `"unsatisfied"` ; `reason`: `string` }

SourceTerms

Ƭ SourceTerms<T>: Object

Type parameters

Name	Type
`T`	extends `Fields` = `Fields`

Type declaration

Name	Type
`revision`	`string`
`values`	`ObjectType`<`T`>
`updatedAt`	`number`

SourceInstallation

Ƭ SourceInstallation<TableInfo>: Object A source installation resolved against its declaration at this read basis. Keep resolution in the query or mutation that uses it; a handle is no grant.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo` = `GenericTableInfo`

Type declaration

Name	Type
`sourceId`	`SourceId`
`table`	`SourceTable`<`TableInfo`>

SourceRecordWork

Ƭ SourceRecordWork: { kind: "idle" } | { kind: "pending" ; generation: string } | { kind: "retrying" ; generation: string ; attempts: number ; nextAttemptAt: number } | { kind: "blocked" ; generation: string ; attempts: number ; reason: SourceContentBlock } Native work for one caller-named provider key. idle means no retained key obligation; it does not prove the item exists or its bytes are ready.

SourceContentBlock

Ƭ SourceContentBlock: "transferLimit" | "providerLimit" | "versionUnavailable" | "providerRejected" Not exported: an exported type refers to it.

SourceFileContract

Ƭ SourceFileContract: { kind: "metadata" ; collection: string ; selectionDigest: string ; acquisitionOwners: string[] } | { kind: "observedVersions" ; collection: string ; origins: string[] ; retainForMs: number ; permissions: { mode: "application" } } | { kind: "copy" ; collection: string ; maximumBytes: number ; resume: "wholeResponse" ; history: { collection: string ; retainForMs: number }[] ; currentMetadata: boolean ; selectionDigest: string | null ; permissions: { mode: "application" } } Capabilities derived from this exact installed native file declaration.

SourceFileContent

Ƭ SourceFileContent: Object Native point state at this query’s exact basis. Previous bytes remain distinct from current readiness; this value grants no byte authority.

Type declaration

Name	Type
`kind`	`"unknown"` \| `"excluded"` \| `"withdrawn"` \| `"pending"` \| `"retrying"` \| `"blocked"` \| `"ready"`
`membership`	`"unknown"` \| `"withdrawn"` \| `"excluded"` \| `"present"`
`selection`	{ `state`: `"included"` } \| { `state`: `"excluded"` ; `reason`: `"selection"` \| `"withdrawn"` \| `"unavailable"` \| `"outside_roots"` \| `"not_folder"` } \| { `state`: `"unresolved"` ; `reason`: `"missing_observation"` \| `"selection_metadata"` \| `"changed_population"` \| `"invalid_parents"` \| `"cycle"` \| `"depth_limit"` \| `"path_unresolved"` } \| `null`
`reason`	`"contentUnavailable"` \| `"accessUnestablished"` \| `SourceContentBlock` \| `null`
`sourceId`	`SourceId`
`metadataSourceId`	`SourceId`
`key`	`string`
`desiredVersion`	`string` \| `null`
`acquiredVersion`	`string` \| `null`
`previousAvailable`	`boolean`
`work`	`SourceRecordWork`
`basis`	{ `metadataObservedAt`: `number` \| `null` ; `contentObservedAt`: `number` \| `null` ; `population`: `"observed"` }
`basis.metadataObservedAt`	`number` \| `null`
`basis.contentObservedAt`	`number` \| `null`
`basis.population`	`"observed"`
`permissions`	{ `mode`: `"application"` }
`permissions.mode`	`"application"`

SourceArtifact

Ƭ SourceArtifact: Object An exact observed copy. A locator grants no future byte access and does not establish that the provider still exposes this version.

Type declaration

Name	Type	Description
`kind`	`"file"`	-
`sourceId`	`SourceId`	-
`key`	`string`	-
`file`	`GenericId`<`"_storage"`>	-
`version`	`string`	Native identity of this exact copy, including its byte digest.
`sha256`	`string`	-
`size`	`string`	-
`contentType`	`string` \| `null`	-
`observedFrom`	`number`	Conservative bounds of the original source observation.
`observedTo`	`number`	-

SourceObservationView

Ƭ SourceObservationView<Row>: { kind: "available" ; value: Row } | { kind: "unavailable" ; reason: "retained-observation-required" } An evidence perspective may require an explicitly authorized historical read.

Type parameters

Name
`Row`

SourceFieldProvenance

Ƭ SourceFieldProvenance: { origin: "source-observation" } | { origin: "native-identity" } | { origin: "confirmed-command" ; command: string ; response: string ; reconciliation: "awaiting-successor-evidence" | "conflicting-confirmed-commands" }

SourceRecordState

Ƭ SourceRecordState<Row>: Object The native external projection and its local decision basis. This basis is not a provider revision or a conditional-write token.

Type parameters

Name
`Row`

Type declaration

Name	Type	Description
`entity`	`string`	Logical source entity lifetime, independent of its serving row ID.
`incarnation`	`string`	The source installation’s incarnation, shared by its entity lifetimes.
`sourceBasis`	`string`	-
`value`	`Row`	-
`observed`	`SourceObservationView`<`Row`>	-
`provenance`	`Record`<`string`, `SourceFieldProvenance`>	-
`ambiguous`	`boolean`	A weak observation disagrees with protected confirmed fields, or concurrent confirmed commands left their order unknown.
`reconciliation`	`"observed"` \| `"awaiting-successor-evidence"` \| `"conflicting-confirmed-commands"` \| `"selected-by-policy"`	`selected-by-policy`: a declared modification-time precedence, not provider evidence, replaced the confirmed values.

SourceFetchValue

Ƭ SourceFetchValue: string | bigint | boolean | ArrayBuffer An exact value a fetch filter compares a declared field with: the value the field is published as. There is no number: an approximate value has no exact equality. An integer column’s value is a bigint; an exact decimal, a date or a timestamp is its canonical text, a decimal at its column’s scale ("12.50", not "12.5").

SourceFetchOptions

Ƭ SourceFetchOptions: Object One pinned, bounded read of an installed source’s table.

Type declaration

Name	Type	Description
`where?`	`Record`<`string`, `SourceFetchValue`>	Declared output fields and the exact values they must equal. Values are bound as parameters; a fetch never carries query text. At most eight. They are also the rows the caller’s read authority is asked for, so a rule that scopes readers by row decides the fetch from them. A page in which the source’s own comparison matched a row whose value differs (a case-insensitive collation, an equal instant at another offset) is refused as `SourceFetchInexactFilter`.
`at?`	`string`	Read at this position, from an earlier receipt’s `position`. Absent, the fetch reads at the source’s current position and names it. The opaque position binds that source incarnation and declaration; it cannot be reused after either changes.
`cursor?`	`string`	Continue an earlier receipt’s page sequence at the same position.
`limit?`	`number`	At most this many rows, 1 through 128. Defaults to 128.

SourceReadPrincipal

Ƭ SourceReadPrincipal: { kind: "user" ; tokenIdentifier: string } | { kind: "administrator" } | { kind: "system" } | { kind: "anonymous" } The Bijection principal a source read ran under. The source itself is read through the installation’s own credential, never as this principal.

SourceReadObservation

Ƭ SourceReadObservation: Object When a source read was answered, of what and under whose authority. It describes one read: nothing about it is retained as a dataset version.

Type declaration

Name	Type	Description
`observedAt`	`number`	Milliseconds since the Unix epoch on the engine’s clock when the source answered. The state read is named by `position`, not by this time.
`incarnation`	`string`	The source installation’s incarnation the rows were read from.
`principal`	`SourceReadPrincipal`	-

SourceFetchReceipt

Ƭ SourceFetchReceipt: Object What a fetch read.

Type declaration

Name	Type	Description
`rows`	`Record`<`string`, `Value`>[]	The declared fields of each row read, in key order, as exact values.
`position`	`string`	The source position every row was read at. Pass it as `at` to read the same state again, for as long as the source retains it.
`cursor`	`string` \| `null`	Where the next page continues, or `null` when the source had no more.
`observation`	`SourceReadObservation`	When this page was read, from which incarnation and under whose authority.

SourceFetchErrorCode

Ƭ SourceFetchErrorCode: "ReadAccess" | "ActionDisclosure" | "IntegrationReinstallRequired" | "SourceFetchArguments" | "SourceFetchUnavailable" | "SourceFetchUnsupported" | "SourceFetchUnpinned" | "SourceFetchUndeclaredField" | "SourceFetchTooManyFilters" | "SourceFetchFilterValue" | "SourceFetchPosition" | "SourceFetchContinuation" | "SourceFetchSourceReplaced" | "SourceFetchHistoryUnavailable" | "SourceFetchRowBound" | "SourceFetchInexactFilter" Why a fetch was refused. ReadAccess: the source’s read rule refused the rows the filters name. ActionDisclosure: the action holds protected information from elsewhere than this source’s rows, which the fetch would send to the source. SourceFetchHistoryUnavailable: the source no longer retains the pinned position; fetch again without at. SourceFetchSourceReplaced: the table is not the installed incarnation. SourceFetchInexactFilter: the source’s comparison matched a row whose value differs from a filter’s.

SourceFetchErrorData

Ƭ SourceFetchErrorData: Object The data of the BijectionError a refused fetch throws.

Type declaration

Name	Type
`kind`	`"source_fetch_error"`
`code`	`SourceFetchErrorCode`

SourceRefreshOptions

Ƭ SourceRefreshOptions: { requestId?: RequestId ; recover?: false } | { requestId: RequestId ; recover: true } Recovery observes the original acceptance and cannot create work.

CapturedSourceNavigation

Ƭ CapturedSourceNavigation: Object

Type declaration

Name	Type
`source`	`string`
`target`	`string`
`pairs`	readonly { `source`: `string` ; `target`: `string` }[]
`[capturedNavigation]`	(`source`: `object`, `target`: `object`) => `void`

ConnectionTaskRequest

Ƭ ConnectionTaskRequest: { connection: string ; controller: { record: string ; protocol: string ; contentRetryMs: readonly string[] } ; request_id?: string } & { task: "setup" ; effect: "inspect" | "verify" } | { task: "setup" ; effect: "install" ; collection: string } | { task: "repair" ; effect: "inspect" | "verify" } | { task: "repair" ; effect: "recover" ; source: string } Native effects of an operator-admitted credential ticket. Usable only from its exact, live, deployment-approved controller’s accepted work.

ConnectionTaskObservation

Ƭ ConnectionTaskObservation: Object

Type declaration

Name	Type
`request_id`	`string`
`sources`	`string`[]
`recovered`	`string`[]
`state`	`ConnectionRepairState`

Camel

Ƭ Camel<S>: S extends `

\{infer A}\_

{infer B}` ? `

\{A}

{Capitalize<Camel<B>>}` : S Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `string`

SourceCapabilities

Ƭ SourceCapabilities: Infer<typeof capabilities>

PublicIssue

Ƭ PublicIssue<T>: T extends string ? Camel<T> : T extends object ? { [K in keyof T]: PublicIssue<T[K]> } : T Not exported: an exported type refers to it.

Type parameters

Name
`T`

SourceRequestIssue

Ƭ SourceRequestIssue: Exclude<PublicIssue<SourceRequestIssue>, { kind: "syncBlocked" }> | { kind: "syncBlocked" ; cause: NonNullable<Extract<PublicIssue<SourceRequestIssue>, { kind: "syncBlocked" }>["cause"]> } | { kind: "unknown" } A blocked owner may not have retained a precise diagnosis. unknown is explicit rather than an invented cause or a nullable failure reason.

SourceUnsupportedCode

Ƭ SourceUnsupportedCode: SourceUnsupportedCode

SourceMissingEvidenceCode

Ƭ SourceMissingEvidenceCode: SourceMissingEvidenceCode

ReadUnavailable

Ƭ ReadUnavailable: { kind: "missingEvidence" ; code: SourceMissingEvidenceCode } | { kind: "unsupported" ; code: SourceUnsupportedCode } Why the actual read could not establish its requirement.

ReadResult

Ƭ ReadResult<T>: { kind: "ready" ; value: T } | ReadUnavailable Availability of the actual native read at the caller’s transaction basis.

Type parameters

Name
`T`

ReadAvailabilityOptions

Ƭ ReadAvailabilityOptions: Object

Type declaration

Name	Type
`availability`	`"return"`

SourceRefreshObservation

Ƭ SourceRefreshObservation: typeof type

ReaderAuthority

Ƭ ReaderAuthority: Object A recipient’s sealed, finite consent for one snapshot reader.

Type declaration

Name	Type	Description
`authority`	`string`	Opaque. It names no person a caller can read or replace.
`expiresAtMs`	`number`	The native end: the earliest of the request, the recipient’s authentication expiry and their session’s end.

SourceTableNames

Ƭ SourceTableNames<DataModel>: string extends keyof DataModel ? string : { [Name in TableNamesInDataModel<DataModel>]: DataModel[Name] extends Object ? Name : never }[TableNamesInDataModel<DataModel>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

SourceTable

Ƭ SourceTable<TableInfo>: Object A source’s exact schema table selected at this transaction basis. Native reads recheck installation, epoch, policy and evidence.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo` = `GenericTableInfo`

Type declaration

Name	Type
`name`	`string`
`[sourceTable]`	{ `info`: `TableInfo` ; `selection`: `SourcePartitionSelection` }
`[sourceTable].info`	`TableInfo`
`[sourceTable].selection`	`SourcePartitionSelection`

SourcePartitionSelection

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

Type declaration

Name	Type
`sourceId`	`SourceId`
`epoch`	`string`

SourceScope

Ƭ SourceScope<TableInfo>: TableInfo extends { sourceScope: infer Scope } ? keyof Scope extends never ? Record<string, never> : Scope : Record<string, Value> The application references required by a scoped source declaration.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

TableSourceSelection

Ƭ TableSourceSelection<TableInfo>: TableInfo extends { sourceScope: infer Scope } ? [Scope] extends [never] ? { scope?: never ; sourceId?: SourceId } : keyof Scope extends never ? { scope?: never ; sourceId?: SourceId } : { scope: Scope ; sourceId?: never } | { sourceId: SourceId ; scope?: never } : { scope?: Record<string, Value> ; sourceId?: never } | { sourceId: SourceId ; scope?: never } How a selection picks one of a table’s sources. A table without application scope may name only itself, selecting its one source; a scoped table names a complete scope. Either may name a source handle instead.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

SourceAcquisitionSelection

Ƭ SourceAcquisitionSelection: Object A history run can span several requests. Only acquisition_id guards recovery.

Type declaration

Name	Type
`acquisitionId`	`string`
`runId`	`string` \| `null`

SourceCoverageKind

SourceReadProtocol

Ƭ SourceReadProtocol: "dataset" | "record_observation" | "change_feed" | "transactional_feed" | "stream_latest"

SourceConsistency

Ƭ SourceConsistency: "observations" | "snapshot"

SourceAtomicity

Ƭ SourceAtomicity: "record" | "source_transaction" | "snapshot"

SourceHistoryKind

Ƭ SourceHistoryKind: "observations" | "complete_changes" | "complete_occurrences" | "latest_state"

ResponseMovement

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

Type declaration

Name	Type
`placement`	`BodyPlacement`
`interpretation`	`BodyInterpretation`
`projectsBeforeRetention`	`boolean`
`retainedBodyLimitBytes`	`string`
`fileLimitBytes`	`string` \| `null`

BodyPlacement

Ƭ BodyPlacement: "retained_bytes" | "protected_file" Not exported: an exported type refers to it.

BodyInterpretation

PlanStep

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

Type declaration

Name	Type
`id`	`string`
`inputs`	`string`[]
`action`	`MovementStep`

MovementStep

Ƭ MovementStep: { operation: "acquire" ; subject: string ; limitBytes: string | null } | { operation: "retain" ; subject: string ; reason: RepresentationReason ; release: MovementRelease } | { operation: "interpret" ; subject: string ; produces: InterpretedOutput } | { operation: "materialize" ; subject: string ; reason: RepresentationReason ; release: MovementRelease } | { operation: "publish" ; subject: string ; visibility: PublicationVisibility } | { operation: "release" ; subject: string ; reach: ProviderReach } Not exported: an exported type refers to it.

RepresentationReason

MovementRelease

Ƭ MovementRelease: "acquisition_custody" | "replacement" | "source_record" | "output_retention" Not exported: an exported type refers to it.

InterpretedOutput

Ƭ InterpretedOutput: "records" | "occurrences" Not exported: an exported type refers to it.

PublicationVisibility

Ƭ PublicationVisibility: "with_acquisition" | "timed" Not exported: an exported type refers to it.

ProviderReach

Ƭ ProviderReach: "acknowledge" | "request" | "remove" | "archive" Not exported: an exported type refers to it.

SourceCommandDelivery

Ƭ SourceCommandDelivery: "idempotent" | "single_attempt" | "at_least_once" Not exported: an exported type refers to it.

SourceCommandCondition

Ƭ SourceCommandCondition: "target_version" | "field_ownership" | "target_state" | "unconditional" Not exported: an exported type refers to it.

ReportQualificationSubject

Ƭ ReportQualificationSubject: Object

Type declaration

Name	Type	Description
`sourceId`	`string`	-
`sourceEpoch`	`string`	-
`connectorDigest`	`string`	-
`configurationDigest`	`string`	-
`decoderDigest`	`string`	-
`runtimeDigest`	`string`	Digest of the running executable, not a caller-supplied release label.
`memoryProfileDigest`	`string`	-
`applicationArtifact`	`string`	-

ReportQualificationPolicy

Ƭ ReportQualificationPolicy: Object

Type declaration

Name	Type	Description
`capability`	`string`	-
`suiteDigest`	`string`	-
`operatingEnvelopeDigest`	`string`	Includes report definition, provider API/layout and correlated capacity limits.
`requiredCases`	`QualificationCaseRequirement`[]	-
`requiredForNewPass`	`boolean`	-

QualificationCaseRequirement

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

Type declaration

Name	Type
`caseId`	`string`
`evidenceKind`	`QualificationEvidenceKind`

QualificationEvidenceKind

Ƭ QualificationEvidenceKind: "native_test" | "controlled_provider" | "real_provider" | "operator_fault" Not exported: an exported type refers to it.

ReportQualificationReceipt

Ƭ ReportQualificationReceipt: Object

Type declaration

Name	Type	Description
`receiptId`	`string`	-
`subject`	`ReportQualificationSubject`	-
`policy`	`ReportQualificationPolicy`	-
`cases`	`ReportQualificationCase`[]	-
`observedAt`	`number`	-
`validUntil`	`number`	-
`cleanupEvidenceDigest`	`string`	-
`evidenceArtifacts`	`Record`<`string`, `string`>	Exact UTF-8 JSON artifacts, keyed by their SHA-256. Every case and cleanup digest resolves here. Native admission hashes and retains the bytes under source custody; no remote URL is accepted as evidence.

ReportQualificationCase

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

Type declaration

Name	Type
`caseId`	`string`
`outcome`	`QualificationOutcome`
`assertionCount`	`number`
`evidenceKind`	`QualificationEvidenceKind`
`evidenceDigest`	`string`

QualificationOutcome

Ƭ QualificationOutcome: "passed" | "failed" | "not_run" | "unresolved" Not exported: an exported type refers to it.

SourceReplicationStatus

Ƭ SourceReplicationStatus: Object

Type declaration

Name	Type	Description
`capturedPosition`	`string` \| `null`	-
`recoveryPosition`	`string` \| `null`	-
`interpretedPosition`	`string` \| `null`	The source interpreter admitted this input. Native and lake representations publish independently and report their own identities.
`acknowledgedPosition`	`string` \| `null`	The last offset completion observed by Bijection; absent when unknown.
`pendingUnits`	`string`	-
`pendingBytes`	`string`	-
`waitingOn`	`SourceCapacityResource` \| `null`	-
`captureFailure`	`string` \| `null`	-
`oldestPending`	`SourceReplicationUnit` \| `null`	-
`snapshotCursor`	`SourceReplicationCursor` \| `null`	-
`staging`	`SourceReplicationStaging` \| `null`	-
`checkedAt`	`number`	-

SourceCapacityResource

Ƭ SourceCapacityResource: "backlog_units" | "backlog_bytes" | "source_custody" | "deployment_custody"

SourceReplicationUnit

Ƭ SourceReplicationUnit: Object

Type declaration

Name	Type	Description
`sequence`	`string`	-
`inputRecords`	`string` \| `null`	-
`inputEncodedBytes`	`string` \| `null`	-
`inputValueBytes`	`string` \| `null`	-
`logicalWireBytes`	`string` \| `null`	-
`kind`	`"snapshot"` \| `"transaction"` \| `"progress"`	-
`retainedBytes`	`string`	-
`observedFrom`	`number`	-
`observedTo`	`number`	-
`ageMs`	`string` \| `null`	Unknown if this host’s clock precedes the retained observation.

SourceReplicationCursor

Ƭ SourceReplicationCursor: Object

Type declaration

Name	Type
`inputPage`	`string`
`inputRow`	`string`

SourceReplicationStaging

Ƭ SourceReplicationStaging: Object

Type declaration

Name	Type
`phase`	`SourceReplicationStage`
`inputPage`	`string`
`inputRow`	`string`
`inputPages`	`string`

SourceReplicationStage

Ƭ SourceReplicationStage: "indexing" | "preparing" | "compacting" | "validating" | "ready"

ResponseIssue

Ƭ ResponseIssue: "required" | "unexpected" | "type" | "literal" | "semantic" Not exported: an exported type refers to it.

RetentionObligation

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

Type declaration

Name	Type
`pin`	`AcquisitionPin`
`step`	`string` \| `null`

AcquisitionPin

IntegrationFailureReason

CheckReceipt

Ƭ CheckReceipt: { kind: "pending" ; admitted_at: string ; expires_at: string } | { kind: "complete" ; admitted_at: string ; expires_at: string ; state: CheckReceiptState ; checked_at: string ; reason: IntegrationFailureReason | null } Exact native receipt observation; decimal timestamps cross without float conversion.

CheckReceiptState

Ƭ CheckReceiptState: "confirmed" | "identity_differs" | "unverified" | "failed" Not exported: an exported type refers to it.

SourceRebuildPreview

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

Type declaration

Name	Type
`source`	`string`
`currentOutput`	`string` \| `null`
`proposedOutput`	`string`
`changedMeaning`	`string`[]

SourceAcquisitionWindow

Ƭ SourceAcquisitionWindow: Object

Type declaration

Name	Type
`oldestSequence`	`string`
`throughSequence`	`string`
`runs`	`SourceAcquisitionRun`[]

SourceAcquisitionRun

Ƭ SourceAcquisitionRun: Object Exact counters are decimal strings; observation times are epoch milliseconds.

Type declaration

Name	Type
`sequence`	`string`
`reason`	`IntegrationFailureReason` \| `null`
`runId`	`string`
`origin`	`SyncOrigin`
`state`	`SyncRunState`
`failure`	`SourceFailure` \| `null`
`startedAt`	`number`
`endedAt`	`number` \| `null`
`pages`	`string`
`requests`	`string`
`responseBytes`	`string`
`records`	`string`
`claims`	`string`
`failedAttempts`	`string`
`publicationRevision`	`string` \| `null`
`observedTo`	`number` \| `null`

SyncOrigin

Ƭ SyncOrigin: "scheduled" | "manual" | "notification" | "reconciliation" | "repair" Not exported: an exported type refers to it.

SyncRunState

Ƭ SyncRunState: "running" | "retrying" | "blocked" | "completed" | "cancelled" Not exported: an exported type refers to it.

ConnectionPage

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

Type declaration

Name	Type
`basis`	`string`
`connections`	`ConnectionStatus`[]
`nextCursor`	`string` \| `null`

ConnectionStatus

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

Type declaration

Name	Type
`connectionName`	`string`
`declaration`	`string`
`generation`	`string`
`enabled`	`boolean`
`verified`	`boolean`
`credentialPresent`	`boolean`
`retired`	`boolean`
`route?`	`ConnectionRoute`

ConnectionRoute

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

Type declaration

Name	Type
`kind`	`ConnectionRouteKind`
`name`	`string`
`targets`	`ConnectionRouteTarget`[]
`configured`	`ConnectionRouteFact`
`attached`	`ConnectionRouteFact`
`connected`	`ConnectionRouteFact`
`reachable`	`ConnectionRouteFact`
`authenticated`	`ConnectionRouteFact`
`operational`	`ConnectionRouteFact`
`qualified`	`ConnectionRouteFact`

ConnectionRouteKind

Ƭ ConnectionRouteKind: "relay" | "endpoint" Not exported: an exported type refers to it.

ConnectionRouteTarget

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

Type declaration

Name	Type
`name`	`string`
`host`	`string`
`port`	`number`
`connected`	`boolean` \| `null`
`gatewayReplicas`	`number` \| `null`

ConnectionRouteFact

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

Type declaration

Name	Type
`value`	`boolean` \| `null`
`observedAt`	`number` \| `null`

ConnectionRepairReceipt

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

Type declaration

Name	Type
`connectionName`	`string`
`requestId`	`string`
`verificationRequest`	`string`
`generation`	`string`
`state`	`ConnectionRepairState`
`cause`	`SourceCause` \| `null`

ConnectionRepairState

SourceControlReply

Ƭ SourceControlReply: { kind: "accepted" ; receipt: SourceControlReceipt } | { kind: "refused" ; code: string ; message: string } Not exported: an exported type refers to it.

SourceRequestSelector

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

Type declaration

Name	Type
`sourceId`	`SourceId`
`requestId`	`RequestId`

ServingSourcePublication

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

Type declaration

Name	Type
`sourceId`	`SourceId`
`epoch`	`SourceEpoch`
`scope`	`string`
`publicationId`	`SourcePublicationId`
`checkpoint`	`SourceCheckpoint` \| `null`

SourceCheckpoint

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

Type declaration

Name	Type
`captureId`	`string`
`position`	`SourcePosition` \| `null`

SourcePosition

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

Type declaration

Name	Type
`space`	`string`
`value`	`string`

SourceDatasetEvidence

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

Type declaration

Name	Type
`component`	`string` \| `null`
`dataset`	`string` \| `null`
`version`	`string` \| `null`
`revision`	`string` \| `null`
`publicationId`	`SourcePublicationId` \| `null`
`coherent`	`boolean`
`completeVersion`	`boolean`

SourceSyncStatus

Ƭ SourceSyncStatus: "scheduled" | "running" | "retrying" | "blocked" | "paused" Not exported: an exported type refers to it.

SourceControls

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

Type declaration

Name	Type
`canRefresh`	`boolean`
`pauseId?`	`string`

SourceRequirementAssessment

Ƭ SourceRequirementAssessment: { kind: "ready" ; next: SourceReadyAction } | { kind: "unsupported" ; code: SourceUnsupportedCode ; next: SourceUnsupportedAction } | { kind: "missingEvidence" ; code: SourceMissingEvidenceCode ; next: SourceEvidenceAction } Not exported: an exported type refers to it.

SourceReadyAction

Ƭ SourceReadyAction: "none" Not exported: an exported type refers to it.

SourceUnsupportedAction

Ƭ SourceUnsupportedAction: "changeRequirement" Not exported: an exported type refers to it.

SourceEvidenceAction

Ƭ SourceEvidenceAction: "requestRefresh" | "wait" | "repairSource" | "inspectSource" Not exported: an exported type refers to it.

SourcePopulationLayout

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

Type declaration

Name	Type
`current`	`string`
`recovery`	`string`
`omissions`	`string`[]
`member`	`SourcePopulationMember`

SourcePopulationMember

Ƭ SourcePopulationMember: "current" | "recovery" Not exported: an exported type refers to it.

SourceRecordRecovery

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

Type declaration

Name	Type
`kind`	`SourceRecoveryKind`
`observation`	`string`
`origin`	`string`
`seen`	`string`

SourceRecoveryKind

Ƭ SourceRecoveryKind: "record" | "population" Not exported: an exported type refers to it.

SourceTableDefinition

Ƭ SourceTableDefinition<Source, Indexes>: SourceTableBuilder<SourceDocumentType<VObject<ObjectType<Source["schema"]>, Source["schema"]>> & { sourceScopeType: Exclude<Source["__scopeType"], undefined> ; sourceContractType: Exclude<Source["__resourceContract"], undefined> }, Indexes> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Source`	extends `SourceHandle`<`any`, `any`, `any`> \| `ResourceTable`<`any`, `any`, `any`>
`Indexes`	extends `GenericTableIndexes` = {}

ResultErrorData

Ƭ ResultErrorData: Object A native answer refusal, released under the input’s current access rules.

Type declaration

Name	Type	Description
`kind`	`"result_error"`	-
`code`	typeof `resultErrorCodes`[`number`]	-
`message`	`string`	-
`context?`	{ `stage`: `"validation"` ; `output`: `string` ; `path`: `string` ; `expression_path?`: `string` } \| `null`	Native-observed location, without row values or provider messages.
`refusal?`	`ResultRefusal` \| `ResultContractRefusal`	The refused disclosure or execution requirement.
`eligibility?`	`EligibilityRefusal`	The executor eligibility requirement this refusal names. Preflight and admission produce the same value for the same static incompatibility.
`next?`	`ResultNextAction`[]	Safe next steps, most useful first.

ResultNextAction

ResultBoundUse

Ƭ ResultBoundUse: Object One execution-contract bound’s use: the effective limit, who set it and what was observed. at_least means counting stopped past the limit.

Type declaration

Name	Type
`limit`	`number`
`owner`	`"author"` \| `"platform"` \| `"provider"`
`observed`	`number`
`at_least?`	`boolean`

ResultContractRefusal

Ƭ ResultContractRefusal: Object The execution contract a contract_refused answer violated: names and counts only, never keys.

Type declaration

Name	Type
`violated`	`"access"` \| `"source_block"` \| `"import"` \| `"imported_keys"` \| `"imported_bytes"`
`edge?`	`number`
`bound?`	`ResultBoundUse`

ResultAccessPath

Ƭ ResultAccessPath: { kind: "index" ; index: string ; fields: string[] } | { kind: "scan" } A local read path, by index and range field names.

ResultContracts

Ƭ ResultContracts: Object A query’s execution contracts in three parts: what the author required, how the engine honoured each requirement (and placed every other statement), and what execution measured.

Type declaration

Name	Type	Description
`required`	({ `kind`: `"access_path"` ; `table`: `string` ; `access`: `ResultAccessPath` ; `ordered_limit?`: `number` } \| { `kind`: `"source_block"` ; `block`: `number` ; `tables`: `string`[] } \| { `kind`: `"import_edge"` ; `edge`: `number` ; `block`: `number` ; `producer`: `string` ; `fields`: `string`[] ; `into`: `string`[] ; `max_keys`: `number` ; `max_bytes?`: `number` })[]	-
`selected`	({ `kind`: `"access_path"` ; `table`: `string` ; `access`: `ResultAccessPath` } \| { `kind`: `"source_block"` ; `block`: `number` ; `statement`: `number` ; `provider`: `"snowflake"` \| `"databricks"` \| `"duckdb"` \| `"clickhouse"` \| `"trino"` \| `"presto"` \| `"bigquery"` \| `"postgresql"` \| `"redshift"` \| `"athena"` \| `"spark"` ; `data_statements`: `number` ; `basis_statements`: `number` } \| { `kind`: `"import_edge"` ; `edge`: `number` ; `statement`: `number` ; `keys?`: `ResultBoundUse` ; `bytes?`: `ResultBoundUse` ; `pending`: `boolean` } \| { `kind`: `"engine"` ; `statement`: `number` ; `tables`: `string`[] })[]	-
`provisional?`	`boolean`	Explain planned from metadata alone: execution may select another plan within the same contracts.
`measured?`	{ `kind`: `"import_edge"` ; `edge`: `number` ; `keys`: `ResultBoundUse` ; `bytes`: `ResultBoundUse` }[]	-

ResultResponse

Ƭ ResultResponse<Result>: { ok: true ; value: Result } | { ok: false ; error: ResultErrorData } Application actions return refusals as data so they pass the ordinary read release gate. An uncaught protected action error remains redacted.

Type parameters

Name
`Result`

ResultValueType

Ƭ ResultValueType: Readonly<{ kind: ResultValueKind | null ; nullable: boolean ; optional: boolean }> Not exported: an exported type refers to it.

ResultValueKind

Ƭ ResultValueKind: "text" | "boolean" | "integer" | "decimal" | "float" | "date" | "time" | "timestamp" | "timestamp_tz" | "binary" | { geometry: { geometry_type: "Point" | "MultiPoint" | "LineString" | "MultiLineString" | "Polygon" | "MultiPolygon" ; space: GeometrySpace } } | { position: { space: GeometrySpace } } | { reference: { table: string } } | { array: { element: ResultValueType } } | { union: { members: ResultValueType[] } } | { record: { key: ResultValueType ; value: ResultValueType } } | { object: { fields: Readonly<Record<string, ResultValueType>> } } Not exported: an exported type refers to it.

ResultPlanSummary

Ƭ ResultPlanSummary: Object The readable first screen of a plan, derived from its other fields: the steps in the order they run, what moves between sites, how each requirement was honoured, each input’s basis, and which numbers are estimates, measurements or enforced limits. Names, counts and bounds only.

Type declaration

Name	Type
`executor`	`ResultPlan`[`"provider"`]
`inputs`	{ `table`: `string` ; `basis`: `"local"` \| `"retained_dataset"` \| `"observed"` }[]
`max_rows`	`number`
`max_bytes`	`number`
`validations`	`string`[]

ResultOutputColumn

Ƭ ResultOutputColumn: Readonly<{ name: string ; kind: ResultValueKind | null ; nullable: boolean ; optional: boolean }>

ResultOutputDescriptor

Ƭ ResultOutputDescriptor<Output>: Output extends { kind: infer Kind ; row: infer Row } ? Kind extends "one" ? Readonly<{ kind: "value" ; value: Row ; columns: readonly ResultOutputColumn[] }> : Readonly<{ kind: "table" ; row_count: number ; columns: readonly ResultOutputColumn[] }> : never Not exported: an exported type refers to it.

Type parameters

Name
`Output`

ResultOutputDescriptors

Ƭ ResultOutputDescriptors<Outputs>: { readonly [Name in keyof Outputs]: ResultOutputDescriptor<Outputs[Name]> } Not exported: an exported type refers to it.

Type parameters

Name
`Outputs`

RelationalCapabilities

Ƭ RelationalCapabilities: Object Metadata evidence only. Execution re-admits the current declaration and authority; this is never a capability to bypass admission.

Type declaration

Name	Type	Description
`inputs`	(`"observed_table"` \| `"retained_snapshot"` \| `"retained_warehouse"`)[]	-
`values`	(`"text"` \| `"boolean"` \| `"integer"` \| `"decimal"` \| `"float"` \| `"date"` \| `"time"` \| `"timestamp"` \| `"timestamp_tz"` \| `"binary"`)[]	-
`is_parameter_relation_supported`	`boolean`	-
`coherence`	`"independent_inputs"` \| `"provider_instant"` \| `"table_versions"`	How observed tables can share a basis: never, at one provider instant pinned at admission, or each at its own pinned table version.
`recovery`	`"original_statement"` \| `"complete_response_only"`	-
`submission`	`"client_identity"` \| `"provider_identity"` \| `"correlation_identity"`	Where the statement’s durable identity comes from. A lost submit reply resumes a client identity; a provider identity becomes `unknown`.
`continuation`	`"checkpointed_pages"` \| `"retained_result"` \| `"complete_response"`	How an interrupted read continues without duplicating rows.
`cancellation`	`"unsupported"` \| `"coordinator_query_state"` \| `"statement_status"` \| `"job_status"` \| `"synchronous_query_kill"`	The provider evidence that proves a cancellation terminal.

EligibilityRequirement

EligibilityRefusal

Ƭ EligibilityRefusal: Object One structured eligibility refusal. It names no physical location.

Type declaration

Name	Type
`code`	`"placement_unsupported"` \| `"recovery_unsupported"` \| `"invalid_definition"` \| `"invalid_binding"` \| `"input_basis_unavailable"` \| `"access_denied"`
`requirement`	`EligibilityRequirement`
`input?`	`string`
`message`	`string`

EligibilityInputRequirement

Ƭ EligibilityInputRequirement: Object One input’s composed requirement: the strongest version and the strictest maximum age per evidence clock.

Type declaration

Name	Type
`version?`	{ `kind`: `"observed"` } \| { `kind`: `"pinned"` } \| { `kind`: `"fixed"` } \| { `kind`: `"exact"` ; `version`: `string` }
`max_age_ms?`	`Partial`<`Record`<`"snapshot"` \| `"coverage"` \| `"publication"` \| `"observation"` \| `"discovery"` \| `"verification"`, `number`>>

InterfacePopulation

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

Type declaration

Name	Type
`name`	`string`
`implementations`	`string`[]
`properties_only`	`boolean`
`implementation_count`	`number`
`selected_implementation_count`	`number`
`relationship_mappings`	`Record`<`string`, `Record`<`string`, { `via`: `string`[] ; `write?`: { `link?`: `string` ; `unlink?`: `"all"` } ; `navigation_count`: `number` ; `membership`: `"distinct_object_identity"` ; `read_strategy`: `"native_navigation"` \| `"bounded_materialization"` ; `min`: `number` ; `max`: `number` \| `null` ; `is_cardinality_check_required`: `boolean` ; `work_limits`: { `read_rows`: `number` ; `read_document_bytes`: `number` \| `null` ; `returned_rows`: `number` ; `returned_entry_bytes`: `number` ; `default_read_subjects`: `number` ; `page_rows`: `number` ; `validation_work`: `number` ; `validation_document_bytes`: `number` } }>>

AdmittedExecution

Ƭ AdmittedExecution: Object

Type declaration

Name	Type
`strategy`	`"external_relational"`
`temporal`	{ `independent_int64_samples`: `boolean` ; `exact_mean_change`: `boolean` }
`temporal.independent_int64_samples`	`boolean`
`temporal.exact_mean_change`	`boolean`
`recovery`	{ `requirements`: `RecoveryRequirements` ; `submission`: `RelationalCapabilities`[`"submission"`] ; `continuation`: `RelationalCapabilities`[`"continuation"`] ; `results`: `RelationalCapabilities`[`"recovery"`] ; `cancellation`: `RelationalCapabilities`[`"cancellation"`] ; `unknown_is_terminal`: `boolean` }
`recovery.requirements`	`RecoveryRequirements`
`recovery.submission`	`RelationalCapabilities`[`"submission"`]
`recovery.continuation`	`RelationalCapabilities`[`"continuation"`]
`recovery.results`	`RelationalCapabilities`[`"recovery"`]
`recovery.cancellation`	`RelationalCapabilities`[`"cancellation"`]
`recovery.unknown_is_terminal`	`boolean`
`provider`	`string`
`connection`	`string`
`inputs`	{ `table`: `string` ; `read`: { `kind`: `"observed"` ; `binding_revision`: `string` } \| { `kind`: `"retained"` ; `input`: `"retained_snapshot"` \| `"retained_warehouse"` ; `version`: `string` } ; `requirement`: `EligibilityInputRequirement` }[]
`native_snapshot_inputs?`	`Record`<`string`, `string`>
`guarantees`	(`"fixed_retained_versions"` \| `"coordinated_native_exports"` \| `"admitted_bindings"` \| `"pinned_observations"` \| `"independent_inputs"` \| `"original_statement_recovery"` \| `"requested_cancellation"`)[]
`limits`	{ `limit`: `"returned_rows"` \| `"returned_bytes"` \| `"duration"` \| `"scanned_bytes"` \| `"provider_billed_bytes_per_run"` ; `value?`: `string` ; `owner`: `"platform"` \| `"provider"` \| `"unenforced"` }[]
`data_dependent`	(`"physical_schema"` \| `"pinned_version"` \| `"freshness"` \| `"current_access"` \| `"result_size"` \| `"statement_protocol"` \| `"result_decoding"`)[]

ExecutorPreflight

Ƭ ExecutorPreflight: Object

Type declaration

Name	Type	Description
`interfaces`	`InterfacePopulation`[]	-
`evidence`	{ `static_analysis`: `"passed"` ; `provider_planning`: `"passed"` \| `"not_run"` ; `workload_qualification`: `"not_run"` }	-
`evidence.static_analysis`	`"passed"`	-
`evidence.provider_planning`	`"passed"` \| `"not_run"`	-
`evidence.workload_qualification`	`"not_run"`	-
`kind`	`"executor_preflight"`	-
`authority`	`"advisory"`	-
`observed_at_micros`	`string` \| `null`	-
`schema_revision`	`string`	-
`read_revision`	`string`	-
`fresh_until`	`string` \| `null`	-
`program_digest`	`string`	-
`executor`	{ `integration`: { `module`: `string` ; `export`: `string` } ; `connection`: `string` ; `generation`: `string` ; `credential_revision`: `string` ; `code_digest`: `string` ; `capabilities`: `RelationalCapabilities` }	-
`executor.integration`	{ `module`: `string` ; `export`: `string` }	-
`executor.integration.module`	`string`	-
`executor.integration.export`	`string`	-
`executor.connection`	`string`	-
`executor.generation`	`string`	-
`executor.credential_revision`	`string`	-
`executor.code_digest`	`string`	-
`executor.capabilities`	`RelationalCapabilities`	-
`bindings`	`Record`<`string`, `string`>	The admitted placement revision of every observed input, by table.
`eligibility`	`AdmittedExecution`	-
`checked`	`string`[]	-
`unchecked`	`string`[]	-

ResultRefusal

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

Type declaration

Name	Type
`refused`	`Crossing`[]

StatementObservation

Ƭ StatementObservation: Readonly<{ result_id: string ; statement_ordinal: number }> Coordinates of one native source read unit, including the verified batches of a pinned probe. They identify the observation without exposing a provider handle or granting authority.

ResultId

Ƭ ResultId<Row>: string & { __result_id?: true } A typed reference, never permission to read a result.

Type parameters

Name	Type
`Row`	`Record`<`string`, `Value`>

UnixNanoseconds

Ƭ UnixNanoseconds: string Not exported: an exported type refers to it.

ResultReadRequirement

Ƭ ResultReadRequirement: Object Fixed input versions or independent observations; a context grants no read authority.

Type declaration

Name	Type
`basisRequirements?`	`BasisRequirements`
`inputContexts?`	`Readonly`<`Record`<`string`, `string`>>

SealedResultPage

Ƭ SealedResultPage<Row>: Object A page is bound to exactly one output of one sealed answer.

Type parameters

Name	Type
`Row`	`Record`<`string`, `Value`>

Type declaration

Name	Type
`result_id`	`ResultId`<`Row`>
`output`	`string`
`content_digest`	`string`
`rows`	`Row`[]
`row_metadata?`	`Omit`<`SnapshotRow`<`Row`>, `"value"`>[]
`next_cursor`	`string` \| `null`

SnapshotRowReference

Ƭ SnapshotRowReference: string & { __snapshotRowReference: unique symbol } Opaque position bound by the native owner to a retained execution and recipe. Possession grants no authority and does not identify a current object.

SnapshotRow

Ƭ SnapshotRow<Row>: Object A snapshot value and its identity travel together.

Type parameters

Name
`Row`

Type declaration

Name	Type	Description
`value`	`Row`	-
`reference`	`SnapshotRowReference`	-
`current_object?`	{ `kind`: `"current_object"` ; `component`: `string` ; `table`: `string` ; `id`: `string` }	Separate current-object navigation; opening it enforces current access.
`current_object.kind`	`"current_object"`	-
`current_object.component`	`string`	-
`current_object.table`	`string`	-
`current_object.id`	`string`	-

ResultDescriptor

Ƭ ResultDescriptor<Outputs>: Readonly<{ id: ResultId<Outputs> ; program_digest: string ; content_digest: string ; completed_at: UnixNanoseconds ; basis: Readonly<ComputationBasis> ; outputs: ResultOutputDescriptors<Outputs> }> Immutable metadata of one complete validated answer. Its execution is its identity; pages and keeps never ask its sources again.

Type parameters

Name	Type
`Outputs`	`RelationalOutputTypes`

KeptResultRef

Ƭ KeptResultRef: string & { __keptResult?: true } A kept result’s identity. Possession grants nothing: every read is decided on the answer’s holder and its file’s current source authority.

ResultRow

Ƭ ResultRow<Expr>: string extends keyof RelationRow<Expr> ? Record<string, Value> : RelationRow<Expr> extends infer Row ? Expand<Row> : never A relation’s rows; a relation read by table name keeps runtime-checked values.

Type parameters

Name
`Expr`

VirtualNavigation

Ƭ VirtualNavigation<Field>: Object A declared navigation of a virtual table: field (one field, or one per key field in key order) names one row of the virtual table to by its declared key.

Type parameters

Name	Type
`Field`	extends `string` = `string`

Type declaration

Name	Type
`field`	`Field` \| readonly `Field`[]
`to`	`string`

VirtualTableDeclaration

Ƭ VirtualTableDeclaration<Fields>: Object A logical relation an installed executor evaluates. Its physical catalog, schema, table and columns are a deployment binding installed with the executor’s connection, never part of the declaration.

Type parameters

Name	Type
`Fields`	extends `PropertyValidators`

Type declaration

Name	Type
`schema`	`Fields`
`executor`	`RelationalExecutor`

RemoteDefinition

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

Type declaration

Name	Type
`source?`	`SourceHandle`<`any`> \| `VirtualDataset`<`any`> \| `CapturedVirtualTable`<`any`>
`schema?`	`PropertyValidators`
`executor?`	`RelationalExecutor`

Variables

connectionPermissionArgs

• Const connectionPermissionArgs: Object Private connection policy inputs. Native custody derives every field; public functions must never forward user-authored values to this query. Membership is an application-owned incarnation that changes on removal and rejoining. Data access remains governed independently by ordinary read policies.

Type declaration

Name	Type
`organization`	`VString`<`string`, `"required"`>
`actor`	`VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`>
`intent`	`VUnion`<`"view"` \| `"inspect"` \| `"use"` \| `"manage"` \| `"background"`, [`VLiteral`<`"manage"`, `"required"`>, `VLiteral`<`"use"`, `"required"`>, `VLiteral`<`"background"`, `"required"`>, `VLiteral`<`"inspect"`, `"required"`>, `VLiteral`<`"view"`, `"required"`>], `"required"`, `never`>
`owner`	`VUnion`<`"personal"` \| `"organization"`, [`VLiteral`<`"personal"`, `"required"`>, `VLiteral`<`"organization"`, `"required"`>], `"required"`, `never`>
`establishedBy`	`VString`<`string`, `"required"`>
`membership`	`VString`<`string`, `"required"`>
`service`	`VUnion`<`null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"required"`, `never`>

connectionPermissionResult

• Const connectionPermissionResult: VObject<{ membership: string ; validUntil: null | number ; allowed: boolean ; membershipActive: boolean }, { allowed: VBoolean<boolean, "required"> ; validUntil: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; membership: VString<string, "required"> ; membershipActive: VBoolean<boolean, "required"> }, "required", "membership" | "validUntil" | "allowed" | "membershipActive">

browserLocator

• Const browserLocator: Readonly<{ role: (role: string, options: { name: string }) => BrowserLocator ; label: (text: string) => BrowserLocator ; testId: (id: string) => BrowserLocator ; css: (selector: string) => BrowserLocator }> Serializable locator declarations for bounded captures. The interaction page exposes the corresponding getByRole/getByLabel/getByTestId/locator methods.

browserCapture

• Const browserCapture: Readonly<{ response: Readonly<{ kind: "response" }> ; page: <Fields>(input: { fields: Fields ; rows?: BrowserLocator ; empty?: BrowserLocator }) => Readonly<{ rows?: BrowserLocator ; empty?: BrowserLocator ; fields: Readonly<Fields> ; kind: "page" }> }> Captures describe observations, never remote population or causal receipts.

browserProtocols

• Const browserProtocols: Object The admitted broker transports. Both carry bounded page commands and send every intercepted page request through the native broker; neither is an unrestricted CDP endpoint. Only enforced also has isolation beneath the browser that blocks traffic bypassing the broker.

Type declaration

Name	Type
`enforced`	`"bijection.browser.broker.v1"`
`unenforced`	`"bijection.browser.unconfined.v1"`

commandRecoveryValidator

• Const commandRecoveryValidator: VObject<{ next: "none" | "send" | "interpret" | "publish" | "wait" | "reconcile" | "attention" ; reason: null | "attemptInFlight" | "attemptNotDispatched" | "providerOutcomeUnknown" | "sendWindowExpired" | "recoveryWindowExpired" | "authorityUnavailable" | "publicationBlocked" | "recoveryBudgetExhausted" | "earlierAttemptUnsettled" | "cancelledOutcomeUnknown" | "waitingForOrder" | "adapterUnsupported" | "duplicateEffects" | "responseContractMismatch" ; nextAtMs: null | number }, { next: VUnion<"none" | "send" | "interpret" | "publish" | "wait" | "reconcile" | "attention", VLiteral<"none" | "send" | "interpret" | "publish" | "wait" | "reconcile" | "attention", "required">[], "required", never> ; reason: VUnion<null | "attemptInFlight" | "attemptNotDispatched" | "providerOutcomeUnknown" | "sendWindowExpired" | "recoveryWindowExpired" | "authorityUnavailable" | "publicationBlocked" | "recoveryBudgetExhausted" | "earlierAttemptUnsettled" | "cancelledOutcomeUnknown" | "waitingForOrder" | "adapterUnsupported" | "duplicateEffects" | "responseContractMismatch", [VNull<null, "required">, …VLiteral<“attemptInFlight” | “attemptNotDispatched” | “providerOutcomeUnknown” | “sendWindowExpired” | “recoveryWindowExpired” | “authorityUnavailable” | “publicationBlocked” | “recoveryBudgetExhausted” | “earlierAttemptUnsettled” | “cancelledOutcomeUnknown” | “waitingForOrder” | “adapterUnsupported” | “duplicateEffects” | “responseContractMismatch”, “required”>[]], "required", never> ; nextAtMs: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> }, "required", "next" | "reason" | "nextAtMs"> Owner-derived recovery observations. They are neither send permissions nor a second lifecycle journal. Only the original owner can progress the command.

commandObservationValidator

• Const commandObservationValidator: VObject<{ revision: number ; recovery: { next: “none” | “send” | “interpret” | “publish” | “wait” | “reconcile” | “attention”; reason: “attemptInFlight” | “attemptNotDispatched” | “providerOutcomeUnknown” | “sendWindowExpired” | … 10 more … | null; nextAtMs: number | null; } ; delivery: { phase: “uncertain” | “blocked” | “refused” | “pending” | “cancelled” | “held” | “delivered” | “queued” | “dispatching” | “notApplied” | “duplicated”; mayHaveDispatched: boolean; settlement: “unbounded” | … 1 more … | “unsettled”; } ; execution: { authorityRevoked: boolean; cancelRequested: boolean; } ; publication: "none" | "blocked" | "running" | "pending" | "complete" ; effect: "unknown" | "applied" | "notApplied" | "duplicated" ; canSubmit: boolean ; recoverUntil: number }, { recovery: VObject<{ next: "none" | "send" | "interpret" | "publish" | "wait" | "reconcile" | "attention" ; reason: null | "attemptInFlight" | "attemptNotDispatched" | "providerOutcomeUnknown" | "sendWindowExpired" | "recoveryWindowExpired" | "authorityUnavailable" | "publicationBlocked" | "recoveryBudgetExhausted" | "earlierAttemptUnsettled" | "cancelledOutcomeUnknown" | "waitingForOrder" | "adapterUnsupported" | "duplicateEffects" | "responseContractMismatch" ; nextAtMs: null | number }, { next: VUnion<"none" | "send" | "interpret" | "publish" | "wait" | "reconcile" | "attention", VLiteral<"none" | "send" | "interpret" | "publish" | "wait" | "reconcile" | "attention", "required">[], "required", never> ; reason: VUnion<null | "attemptInFlight" | "attemptNotDispatched" | "providerOutcomeUnknown" | "sendWindowExpired" | "recoveryWindowExpired" | "authorityUnavailable" | "publicationBlocked" | "recoveryBudgetExhausted" | "earlierAttemptUnsettled" | "cancelledOutcomeUnknown" | "waitingForOrder" | "adapterUnsupported" | "duplicateEffects" | "responseContractMismatch", [VNull<null, "required">, …VLiteral<“attemptInFlight” | “attemptNotDispatched” | “providerOutcomeUnknown” | “sendWindowExpired” | “recoveryWindowExpired” | “authorityUnavailable” | “publicationBlocked” | “recoveryBudgetExhausted” | “earlierAttemptUnsettled” | “cancelledOutcomeUnknown” | “waitingForOrder” | “adapterUnsupported” | “duplicateEffects” | “responseContractMismatch”, “required”>[]], "required", never> ; nextAtMs: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> }, "required", "next" | "reason" | "nextAtMs"> = commandRecoveryValidator; revision: VFloat64<number, "required"> ; delivery: VObject<{ phase: "uncertain" | "blocked" | "refused" | "pending" | "cancelled" | "held" | "delivered" | "queued" | "dispatching" | "notApplied" | "duplicated" ; mayHaveDispatched: boolean ; settlement: "unbounded" | "settled" | "unsettled" }, { phase: VUnion<"uncertain" | "blocked" | "refused" | "pending" | "cancelled" | "held" | "delivered" | "queued" | "dispatching" | "notApplied" | "duplicated", VLiteral<"uncertain" | "blocked" | "refused" | "pending" | "cancelled" | "held" | "delivered" | "queued" | "dispatching" | "notApplied" | "duplicated", "required">[], "required", never> ; mayHaveDispatched: VBoolean<boolean, "required"> ; settlement: VUnion<"unbounded" | "settled" | "unsettled", [VLiteral<"settled", "required">, VLiteral<"unsettled", "required">, VLiteral<"unbounded", "required">], "required", never> }, "required", "phase" | "mayHaveDispatched" | "settlement"> ; effect: VUnion<"unknown" | "applied" | "notApplied" | "duplicated", [VLiteral<"applied", "required">, VLiteral<"notApplied", "required">, VLiteral<"duplicated", "required">, VLiteral<"unknown", "required">], "required", never> ; publication: VUnion<"none" | "blocked" | "running" | "pending" | "complete", VLiteral<"none" | "blocked" | "running" | "pending" | "complete", "required">[], "required", never> ; execution: VObject<{ authorityRevoked: boolean ; cancelRequested: boolean }, { authorityRevoked: VBoolean<boolean, "required"> ; cancelRequested: VBoolean<boolean, "required"> }, "required", "authorityRevoked" | "cancelRequested"> ; recoverUntil: VFloat64<number, "required"> ; canSubmit: VBoolean<boolean, "required"> }, "required", "revision" | "recovery" | "delivery" | "execution" | "publication" | "effect" | "canSubmit" | "recoverUntil" | "recovery.next" | "recovery.reason" | "recovery.nextAtMs" | "delivery.phase" | "delivery.mayHaveDispatched" | "delivery.settlement" | "execution.authorityRevoked" | "execution.cancelRequested">

ewsConnectionSetup

• Const ewsConnectionSetup: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`ews`	`VObject`<{ `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `security`: `VUnion`<`"implicit_tls"` \| `"start_tls"` \| `"loopback"`, [`VLiteral`<`"implicit_tls"`, `"required"`>, `VLiteral`<`"start_tls"`, `"required"`>, `VLiteral`<`"loopback"`, `"required"`>], `"required"`, `never`> }, `"required"`, `"host"` \| `"port"` \| `"security"`>
`folders`	`VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>

nativeConnectionSchemas

• Const nativeConnectionSchemas: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`dataset`	{ `endpoint`: `VString`<`string`, `"required"`> }
`dataset.endpoint`	`VString`<`string`, `"required"`>
`kubernetes`	{ `endpoint`: `VString`<`string`, `"required"`> ; `namespace`: `VString`<`string`, `"required"`> ; `apiGroup`: `VString`<`undefined` \| `string`, `"optional"`> ; `apiVersion`: `VString`<`string`, `"required"`> ; `resource`: `VString`<`string`, `"required"`> }
`kubernetes.endpoint`	`VString`<`string`, `"required"`>
`kubernetes.namespace`	`VString`<`string`, `"required"`>
`kubernetes.apiGroup`	`VString`<`undefined` \| `string`, `"optional"`>
`kubernetes.apiVersion`	`VString`<`string`, `"required"`>
`kubernetes.resource`	`VString`<`string`, `"required"`>
`big_query`	{ `project`: `VString`<`string`, `"required"`> ; `dataset`: `VString`<`string`, `"required"`> ; `table`: `VString`<`string`, `"required"`> ; `location`: `VString`<`string`, `"required"`> ; `startUs`: `VInt64`<`bigint`, `"required"`> ; `maximumBytesBilled`: `VInt64`<`bigint`, `"required"`> }
`big_query.project`	`VString`<`string`, `"required"`>
`big_query.dataset`	`VString`<`string`, `"required"`>
`big_query.table`	`VString`<`string`, `"required"`>
`big_query.location`	`VString`<`string`, `"required"`>
`big_query.startUs`	`VInt64`<`bigint`, `"required"`>
`big_query.maximumBytesBilled`	`VInt64`<`bigint`, `"required"`>
`bayeux`	{ `instance`: `VString`<`undefined` \| `string`, `"optional"`> ; `channel`: `VString`<`string`, `"required"`> }
`bayeux.instance`	`VString`<`undefined` \| `string`, `"optional"`>
`bayeux.channel`	`VString`<`string`, `"required"`>
`salesforce`	{ `instance`: `VString`<`undefined` \| `string`, `"optional"`> }
`salesforce.instance`	`VString`<`undefined` \| `string`, `"optional"`>
`dynamo_db`	{ `endpoint`: `VString`<`string`, `"required"`> ; `streamsEndpoint`: `VString`<`string`, `"required"`> ; `table`: `VString`<`string`, `"required"`> ; `region`: `VString`<`string`, `"required"`> }
`dynamo_db.endpoint`	`VString`<`string`, `"required"`>
`dynamo_db.streamsEndpoint`	`VString`<`string`, `"required"`>
`dynamo_db.table`	`VString`<`string`, `"required"`>
`dynamo_db.region`	`VString`<`string`, `"required"`>
`mongo`	{ `uri`: `VString`<`string`, `"required"`> ; `database`: `VString`<`string`, `"required"`> ; `collections`: `VRecord`<`Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"required"`, `string`> ; `pinnedSeeds`: `VBoolean`<`undefined` \| `boolean`, `"optional"`> }
`mongo.uri`	`VString`<`string`, `"required"`>
`mongo.database`	`VString`<`string`, `"required"`>
`mongo.collections`	`VRecord`<`Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"required"`, `string`>
`mongo.pinnedSeeds`	`VBoolean`<`undefined` \| `boolean`, `"optional"`>
`bijection`	{ `deploymentUrl`: `VString`<`string`, `"required"`> ; `table`: `VString`<`string`, `"required"`> ; `component`: `VString`<`undefined` \| `string`, `"optional"`> }
`bijection.deploymentUrl`	`VString`<`string`, `"required"`>
`bijection.table`	`VString`<`string`, `"required"`>
`bijection.component`	`VString`<`undefined` \| `string`, `"optional"`>
`kafka`	{ `topic`: `VString`<`string`, `"required"`> ; `broker`: `VString`<`string`, `"required"`> ; `schemaRegistry`: `VObject`<`undefined` \| { `bindings`: `undefined` \| `Record`<`string`, { key?: { contract: string; writers: Record<string, string>; }; contract: string; writers: Record<string, string>; }> ; `endpoint`: `string` }, { `endpoint`: `VString`<`string`, `"required"`> ; `bindings`: `VRecord`<`undefined` \| `Record`<`string`, { `key`: `undefined` \| { contract: string; writers: Record<string, string>; } ; `contract`: `string` ; `writers`: `Record`<`string`, `string`> }>, `VString`<`string`, `"required"`>, `VObject`<{ `key`: `undefined` \| { contract: string; writers: Record<string, string>; } ; `contract`: `string` ; `writers`: `Record`<`string`, `string`> }, { `contract`: `VString`<`string`, `"required"`> ; `writers`: `VRecord`<`Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"required"`, `string`> ; `key`: `VObject`<`undefined` \| { `contract`: `string` ; `writers`: `Record`<`string`, `string`> }, { `contract`: `VString`<`string`, `"required"`> ; `writers`: `VRecord`<`Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"required"`, `string`> }, `"optional"`, `"contract"` \| `"writers"` \| `writers. $\{string}\`\> \}, ``"required"``, ``"key"`` \\| ``"contract"`` \\| ``"writers"`` \\| \`writers.$ {string}` \| `"key.contract"` \| `"key.writers"` \| `key.writers. $\{string}\`\>, ``"optional"``, `string`\> \}, ``"optional"``, ``"endpoint"`` \\| ``"bindings"`` \\| \`bindings.$ {string}`> }
`kafka.topic`	`VString`<`string`, `"required"`>
`kafka.broker`	`VString`<`string`, `"required"`>
`kafka.schemaRegistry`	`VObject`<`undefined` \| { `bindings`: `undefined` \| `Record`<`string`, { key?: { contract: string; writers: Record<string, string>; }; contract: string; writers: Record<string, string>; }> ; `endpoint`: `string` }, { `endpoint`: `VString`<`string`, `"required"`> ; `bindings`: `VRecord`<`undefined` \| `Record`<`string`, { `key`: `undefined` \| { contract: string; writers: Record<string, string>; } ; `contract`: `string` ; `writers`: `Record`<`string`, `string`> }>, `VString`<`string`, `"required"`>, `VObject`<{ `key`: `undefined` \| { contract: string; writers: Record<string, string>; } ; `contract`: `string` ; `writers`: `Record`<`string`, `string`> }, { `contract`: `VString`<`string`, `"required"`> ; `writers`: `VRecord`<`Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"required"`, `string`> ; `key`: `VObject`<`undefined` \| { `contract`: `string` ; `writers`: `Record`<`string`, `string`> }, { `contract`: `VString`<`string`, `"required"`> ; `writers`: `VRecord`<`Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"required"`, `string`> }, `"optional"`, `"contract"` \| `"writers"` \| `writers. $\{string}\`\> \}, ``"required"``, ``"key"`` \\| ``"contract"`` \\| ``"writers"`` \\| \`writers.$ {string}` \| `"key.contract"` \| `"key.writers"` \| `key.writers. $\{string}\`\>, ``"optional"``, `string`\> \}, ``"optional"``, ``"endpoint"`` \\| ``"bindings"`` \\| \`bindings.$ {string}`>
`pulsar`	{ `topic`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `subscription`: `VString`<`string`, `"required"`> }
`pulsar.topic`	`VString`<`string`, `"required"`>
`pulsar.endpoint`	`VString`<`string`, `"required"`>
`pulsar.subscription`	`VString`<`string`, `"required"`>
`kinesis`	{ `stream`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `region`: `VString`<`string`, `"required"`> }
`kinesis.stream`	`VString`<`string`, `"required"`>
`kinesis.endpoint`	`VString`<`string`, `"required"`>
`kinesis.region`	`VString`<`string`, `"required"`>
`pubsub`	{ `endpoint`: `VString`<`undefined` \| `string`, `"optional"`> ; `subscription`: `VString`<`string`, `"required"`> }
`pubsub.endpoint`	`VString`<`undefined` \| `string`, `"optional"`>
`pubsub.subscription`	`VString`<`string`, `"required"`>
`sqs`	{ `endpoint`: `VString`<`string`, `"required"`> ; `queueUrl`: `VString`<`string`, `"required"`> ; `region`: `VString`<`string`, `"required"`> ; `snsTopicArn`: `VString`<`undefined` \| `string`, `"optional"`> }
`sqs.endpoint`	`VString`<`string`, `"required"`>
`sqs.queueUrl`	`VString`<`string`, `"required"`>
`sqs.region`	`VString`<`string`, `"required"`>
`sqs.snsTopicArn`	`VString`<`undefined` \| `string`, `"optional"`>
`servicebus`	{ `entity`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `subscription`: `VString`<`undefined` \| `string`, `"optional"`> }
`servicebus.entity`	`VString`<`string`, `"required"`>
`servicebus.endpoint`	`VString`<`string`, `"required"`>
`servicebus.subscription`	`VString`<`undefined` \| `string`, `"optional"`>
`redis`	{ `stream`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `identityKey`: `VString`<`string`, `"required"`> ; `database`: `VFloat64`<`undefined` \| `number`, `"optional"`> }
`redis.stream`	`VString`<`string`, `"required"`>
`redis.endpoint`	`VString`<`string`, `"required"`>
`redis.identityKey`	`VString`<`string`, `"required"`>
`redis.database`	`VFloat64`<`undefined` \| `number`, `"optional"`>
`jetstream`	{ `stream`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `apiPrefix`: `VString`<`undefined` \| `string`, `"optional"`> }
`jetstream.stream`	`VString`<`string`, `"required"`>
`jetstream.endpoint`	`VString`<`string`, `"required"`>
`jetstream.apiPrefix`	`VString`<`undefined` \| `string`, `"optional"`>
`rabbitmq`	{ `stream`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `managementEndpoint`: `VString`<`string`, `"required"`> ; `virtualHost`: `VString`<`string`, `"required"`> }
`rabbitmq.stream`	`VString`<`string`, `"required"`>
`rabbitmq.endpoint`	`VString`<`string`, `"required"`>
`rabbitmq.managementEndpoint`	`VString`<`string`, `"required"`>
`rabbitmq.virtualHost`	`VString`<`string`, `"required"`>
`rabbitmq_queue`	{ `queue`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `managementEndpoint`: `VString`<`string`, `"required"`> ; `virtualHost`: `VString`<`string`, `"required"`> }
`rabbitmq_queue.queue`	`VString`<`string`, `"required"`>
`rabbitmq_queue.endpoint`	`VString`<`string`, `"required"`>
`rabbitmq_queue.managementEndpoint`	`VString`<`string`, `"required"`>
`rabbitmq_queue.virtualHost`	`VString`<`string`, `"required"`>
`mqtt`	{ `topic`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `clientId`: `VString`<`string`, `"required"`> ; `identityEndpoint`: `VString`<`string`, `"required"`> }
`mqtt.topic`	`VString`<`string`, `"required"`>
`mqtt.endpoint`	`VString`<`string`, `"required"`>
`mqtt.clientId`	`VString`<`string`, `"required"`>
`mqtt.identityEndpoint`	`VString`<`string`, `"required"`>
`stomp`	{ `destination`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `sourceEpoch`: `VString`<`string`, `"required"`> ; `virtualHost`: `VString`<`undefined` \| `string`, `"optional"`> }
`stomp.destination`	`VString`<`string`, `"required"`>
`stomp.endpoint`	`VString`<`string`, `"required"`>
`stomp.sourceEpoch`	`VString`<`string`, `"required"`>
`stomp.virtualHost`	`VString`<`undefined` \| `string`, `"optional"`>
`sql`	{ `connection`: `VUnion`<{ `kind`: `"clickhouse"` ; `endpoint`: `string` } \| { `kind`: `"executor"` ; `endpoint`: `string` ; `engine`: `string` } \| { `kind`: `"gateway"` ; `endpoint`: `string` ; `connection`: { properties?: Record<string, string>; port?: number \| null; instance?: string \| null; database?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { properties?: Record<string, string>; kind: “url”; url: string; quote: “double” \| “backtick” \| “bracket”; } \| { kind: “quack”; host: string; port: number; database: string; } } \| { `role`: `undefined` \| `null` \| `string` ; `kind`: `"snowflake"` ; `endpoint`: `string` ; `warehouse`: `string` } \| { `kind`: `"bigquery"` ; `endpoint`: `string` ; `location`: `string` ; `project`: `string` ; `maxBytesBilled`: `string` } \| { `statementTimeoutSeconds`: `undefined` \| `number` ; `kind`: `"databricks"` ; `endpoint`: `string` ; `warehouseId`: `string` }, [`VObject`<{ `kind`: `"clickhouse"` ; `endpoint`: `string` }, { `kind`: `VLiteral`<`"clickhouse"`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"endpoint"`>, `VObject`<{ `kind`: `"executor"` ; `endpoint`: `string` ; `engine`: `string` }, { `kind`: `VLiteral`<`"executor"`, `"required"`> ; `engine`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"endpoint"` \| `"engine"`>, `VObject`<{ `kind`: `"gateway"` ; `endpoint`: `string` ; `connection`: { properties?: Record<string, string>; port?: number \| null; instance?: string \| null; database?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { properties?: Record<string, string>; kind: “url”; url: string; quote: “double” \| “backtick” \| “bracket”; } \| { kind: “quack”; host: string; port: number; database: string; } }, { `kind`: `VLiteral`<`"gateway"`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `connection`: `VUnion`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` } \| { `properties`: `undefined` \| `Record`<`string`, `string`> ; `kind`: `"url"` ; `url`: `string` ; `quote`: `"double"` \| `"backtick"` \| `"bracket"` } \| { `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, [`VObject`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` }, { `kind`: `VLiteral`<`"server"`, `"required"`> ; `host`: `VString`<`string`, `"required"`> ; `port`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `instance`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `database`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `readFrom`: `VUnion`<`undefined` \| `"primary"` \| `"readable_secondary"`, [`VLiteral`<`"primary"`, `"required"`>, `VLiteral`<`"readable_secondary"`, `"required"`>], `"optional"`, `never`> ; `replicaServerId`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `properties`: `VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`> }, `"required"`, `"kind"` \| `"properties"` \| `"host"` \| `"port"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `kind`: ``"url"`` ; `url`: `string` ; `quote`: ``"double"`` \\| ``"backtick"`` \\| ``"bracket"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"url"``, ``"required"``\> ; `url`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `quote`: [`VUnion`](/api/classes/values.VUnion)\<``"double"`` \\| ``"backtick"`` \\| ``"bracket"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"double"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"backtick"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"bracket"``, ``"required"``\>], ``"required"``, `never`\> ; `properties`: [`VRecord`](/api/classes/values.VRecord)\<`undefined` \\| `Record`\<`string`, `string`\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, ``"optional"``, `string`\> \}, ``"required"``, ``"kind"`` \\| ``"properties"`` \\| ``"url"`` \\| ``"quote"`` \\| \`properties.$ {string}`>, `VObject`<{ `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, { `kind`: `VLiteral`<`"quack"`, `"required"`> ; `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `database`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"host"` \| `"port"` \| `"database"`>], `"required"`, `"kind"` \| `"properties"` \| `"host"` \| `"url"` \| `"port"` \| `"quote"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\> = gatewayDatabase \}, ``"required"``, ``"kind"`` \\| ``"endpoint"`` \\| ``"connection"`` \\| ``"connection.kind"`` \\| ``"connection.properties"`` \\| ``"connection.host"`` \\| ``"connection.url"`` \\| ``"connection.port"`` \\| ``"connection.quote"`` \\| ``"connection.instance"`` \\| ``"connection.database"`` \\| ``"connection.readFrom"`` \\| ``"connection.replicaServerId"`` \\| \`connection.properties.$ {string}`>], `"required"`, `"kind"` \| `"endpoint"` \| `"role"` \| `"location"` \| `"connection"` \| `"project"` \| `"engine"` \| `"warehouse"` \| `"connection.kind"` \| `"connection.properties"` \| `"connection.host"` \| `"connection.url"` \| `"connection.port"` \| `"connection.quote"` \| `"connection.instance"` \| `"connection.database"` \| `"connection.readFrom"` \| `"connection.replicaServerId"` \| `connection.properties. $\{string}\` \\| ``"maxBytesBilled"`` \\| ``"warehouseId"`` \\| ``"statementTimeoutSeconds"``\> ; `table`: [`VObject`](/api/classes/values.VObject)\<`undefined` \\| \{ `schema`: `undefined` \\| ``null`` \\| `string` ; `database`: `undefined` \\| ``null`` \\| `string` ; `name`: `string` \}, \{ `database`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `schema`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `name`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> \}, ``"optional"``, ``"name"`` \\| ``"schema"`` \\| ``"database"``\> ; `receipts`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| \{ `schema`: `undefined` \\| ``null`` \\| `string` ; `database`: `undefined` \\| ``null`` \\| `string` ; `name`: `string` \}, [[`VObject`](/api/classes/values.VObject)\<\{ `schema`: `undefined` \\| ``null`` \\| `string` ; `database`: `undefined` \\| ``null`` \\| `string` ; `name`: `string` \}, \{ `database`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `schema`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `name`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> \}, ``"required"``, ``"name"`` \\| ``"schema"`` \\| ``"database"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, ``"name"`` \\| ``"schema"`` \\| ``"database"``\> ; `changeRecord`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| \{ `kind`: ``"capture"`` ; `captureInstance`: `string` \} \\| \{ `root`: `undefined` \\| ``null`` \\| \{ properties?: Record\<string, string\>; port?: number \\| null; instance?: string \\| null; database?: string \\| null; readFrom?: "primary" \\| "readable\_secondary"; replicaServerId?: number \\| null; kind: "server"; host: string; \} \\| \{ properties?: Record\<string, string\>; kind: "url"; url: string; quote: "double" \\| "backtick" \\| "bracket"; \} \\| \{ kind: "quack"; host: string; port: number; database: string; \} ; `kind`: ``"logminer"`` \}, [[`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"capture"`` ; `captureInstance`: `string` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"capture"``, ``"required"``\> ; `captureInstance`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> \}, ``"required"``, ``"kind"`` \\| ``"captureInstance"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `root`: `undefined` \\| ``null`` \\| \{ properties?: Record\<string, string\>; port?: number \\| null; instance?: string \\| null; database?: string \\| null; readFrom?: "primary" \\| "readable\_secondary"; replicaServerId?: number \\| null; kind: "server"; host: string; \} \\| \{ properties?: Record\<string, string\>; kind: "url"; url: string; quote: "double" \\| "backtick" \\| "bracket"; \} \\| \{ kind: "quack"; host: string; port: number; database: string; \} ; `kind`: ``"logminer"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"logminer"``, ``"required"``\> ; `root`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| \{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `port`: `undefined` \\| ``null`` \\| `number` ; `instance`: `undefined` \\| ``null`` \\| `string` ; `database`: `undefined` \\| ``null`` \\| `string` ; `readFrom`: `undefined` \\| ``"primary"`` \\| ``"readable_secondary"`` ; `replicaServerId`: `undefined` \\| ``null`` \\| `number` ; `kind`: ``"server"`` ; `host`: `string` \} \\| \{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `kind`: ``"url"`` ; `url`: `string` ; `quote`: ``"double"`` \\| ``"backtick"`` \\| ``"bracket"`` \} \\| \{ `kind`: ``"quack"`` ; `host`: `string` ; `port`: `number` ; `database`: `string` \}, [[`VUnion`](/api/classes/values.VUnion)\<\{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `port`: `undefined` \\| ``null`` \\| `number` ; `instance`: `undefined` \\| ``null`` \\| `string` ; `database`: `undefined` \\| ``null`` \\| `string` ; `readFrom`: `undefined` \\| ``"primary"`` \\| ``"readable_secondary"`` ; `replicaServerId`: `undefined` \\| ``null`` \\| `number` ; `kind`: ``"server"`` ; `host`: `string` \} \\| \{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `kind`: ``"url"`` ; `url`: `string` ; `quote`: ``"double"`` \\| ``"backtick"`` \\| ``"bracket"`` \} \\| \{ `kind`: ``"quack"`` ; `host`: `string` ; `port`: `number` ; `database`: `string` \}, [[`VObject`](/api/classes/values.VObject)\<\{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `port`: `undefined` \\| ``null`` \\| `number` ; `instance`: `undefined` \\| ``null`` \\| `string` ; `database`: `undefined` \\| ``null`` \\| `string` ; `readFrom`: `undefined` \\| ``"primary"`` \\| ``"readable_secondary"`` ; `replicaServerId`: `undefined` \\| ``null`` \\| `number` ; `kind`: ``"server"`` ; `host`: `string` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"server"``, ``"required"``\> ; `host`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `port`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `number`, [[`VFloat64`](/api/classes/values.VFloat64)\<`number`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `instance`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `database`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `string`, [[`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `readFrom`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``"primary"`` \\| ``"readable_secondary"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"primary"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"readable_secondary"``, ``"required"``\>], ``"optional"``, `never`\> ; `replicaServerId`: [`VUnion`](/api/classes/values.VUnion)\<`undefined` \\| ``null`` \\| `number`, [[`VFloat64`](/api/classes/values.VFloat64)\<`number`, ``"required"``\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, `never`\> ; `properties`: [`VRecord`](/api/classes/values.VRecord)\<`undefined` \\| `Record`\<`string`, `string`\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, ``"optional"``, `string`\> \}, ``"required"``, ``"kind"`` \\| ``"properties"`` \\| ``"host"`` \\| ``"port"`` \\| ``"instance"`` \\| ``"database"`` \\| ``"readFrom"`` \\| ``"replicaServerId"`` \\| \`properties.$ {string}`>, `VObject`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `kind`: `"url"` ; `url`: `string` ; `quote`: `"double"` \| `"backtick"` \| `"bracket"` }, { `kind`: `VLiteral`<`"url"`, `"required"`> ; `url`: `VString`<`string`, `"required"`> ; `quote`: `VUnion`<`"double"` \| `"backtick"` \| `"bracket"`, [`VLiteral`<`"double"`, `"required"`>, `VLiteral`<`"backtick"`, `"required"`>, `VLiteral`<`"bracket"`, `"required"`>], `"required"`, `never`> ; `properties`: `VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`> }, `"required"`, `"kind"` \| `"properties"` \| `"url"` \| `"quote"` \| `properties. $\{string}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"quack"`` ; `host`: `string` ; `port`: `number` ; `database`: `string` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"quack"``, ``"required"``\> ; `host`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `port`: [`VFloat64`](/api/classes/values.VFloat64)\<`number`, ``"required"``\> ; `database`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> \}, ``"required"``, ``"kind"`` \\| ``"host"`` \\| ``"port"`` \\| ``"database"``\>], ``"required"``, ``"kind"`` \\| ``"properties"`` \\| ``"host"`` \\| ``"url"`` \\| ``"port"`` \\| ``"quote"`` \\| ``"instance"`` \\| ``"database"`` \\| ``"readFrom"`` \\| ``"replicaServerId"`` \\| \`properties.$ {string}`>, `VNull`<`null`, `"required"`>], `"optional"`, `"kind"` \| `"properties"` \| `"host"` \| `"url"` \| `"port"` \| `"quote"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\> \}, ``"required"``, ``"kind"`` \\| ``"root"`` \\| ``"root.kind"`` \\| ``"root.properties"`` \\| ``"root.host"`` \\| ``"root.url"`` \\| ``"root.port"`` \\| ``"root.quote"`` \\| ``"root.instance"`` \\| ``"root.database"`` \\| ``"root.readFrom"`` \\| ``"root.replicaServerId"`` \\| \`root.properties.$ {string}`>], `"optional"`, `"kind"` \| `"root"` \| `"captureInstance"` \| `"root.kind"` \| `"root.properties"` \| `"root.host"` \| `"root.url"` \| `"root.port"` \| `"root.quote"` \| `"root.instance"` \| `"root.database"` \| `"root.readFrom"` \| `"root.replicaServerId"` \| `root.properties.${string}`> ; `icebergCatalogs`: `VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`> }
`sql.connection`	`VUnion`<{ `kind`: `"clickhouse"` ; `endpoint`: `string` } \| { `kind`: `"executor"` ; `endpoint`: `string` ; `engine`: `string` } \| { `kind`: `"gateway"` ; `endpoint`: `string` ; `connection`: { properties?: Record<string, string>; port?: number \| null; instance?: string \| null; database?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { properties?: Record<string, string>; kind: “url”; url: string; quote: “double” \| “backtick” \| “bracket”; } \| { kind: “quack”; host: string; port: number; database: string; } } \| { `role`: `undefined` \| `null` \| `string` ; `kind`: `"snowflake"` ; `endpoint`: `string` ; `warehouse`: `string` } \| { `kind`: `"bigquery"` ; `endpoint`: `string` ; `location`: `string` ; `project`: `string` ; `maxBytesBilled`: `string` } \| { `statementTimeoutSeconds`: `undefined` \| `number` ; `kind`: `"databricks"` ; `endpoint`: `string` ; `warehouseId`: `string` }, [`VObject`<{ `kind`: `"clickhouse"` ; `endpoint`: `string` }, { `kind`: `VLiteral`<`"clickhouse"`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"endpoint"`>, `VObject`<{ `kind`: `"executor"` ; `endpoint`: `string` ; `engine`: `string` }, { `kind`: `VLiteral`<`"executor"`, `"required"`> ; `engine`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"endpoint"` \| `"engine"`>, `VObject`<{ `kind`: `"gateway"` ; `endpoint`: `string` ; `connection`: { properties?: Record<string, string>; port?: number \| null; instance?: string \| null; database?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { properties?: Record<string, string>; kind: “url”; url: string; quote: “double” \| “backtick” \| “bracket”; } \| { kind: “quack”; host: string; port: number; database: string; } }, { `kind`: `VLiteral`<`"gateway"`, `"required"`> ; `endpoint`: `VString`<`string`, `"required"`> ; `connection`: `VUnion`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` } \| { `properties`: `undefined` \| `Record`<`string`, `string`> ; `kind`: `"url"` ; `url`: `string` ; `quote`: `"double"` \| `"backtick"` \| `"bracket"` } \| { `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, [`VObject`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` }, { `kind`: `VLiteral`<`"server"`, `"required"`> ; `host`: `VString`<`string`, `"required"`> ; `port`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `instance`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `database`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `readFrom`: `VUnion`<`undefined` \| `"primary"` \| `"readable_secondary"`, [`VLiteral`<`"primary"`, `"required"`>, `VLiteral`<`"readable_secondary"`, `"required"`>], `"optional"`, `never`> ; `replicaServerId`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `properties`: `VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`> }, `"required"`, `"kind"` \| `"properties"` \| `"host"` \| `"port"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `kind`: ``"url"`` ; `url`: `string` ; `quote`: ``"double"`` \\| ``"backtick"`` \\| ``"bracket"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"url"``, ``"required"``\> ; `url`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `quote`: [`VUnion`](/api/classes/values.VUnion)\<``"double"`` \\| ``"backtick"`` \\| ``"bracket"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"double"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"backtick"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"bracket"``, ``"required"``\>], ``"required"``, `never`\> ; `properties`: [`VRecord`](/api/classes/values.VRecord)\<`undefined` \\| `Record`\<`string`, `string`\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, ``"optional"``, `string`\> \}, ``"required"``, ``"kind"`` \\| ``"properties"`` \\| ``"url"`` \\| ``"quote"`` \\| \`properties.$ {string}`>, `VObject`<{ `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, { `kind`: `VLiteral`<`"quack"`, `"required"`> ; `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `database`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"host"` \| `"port"` \| `"database"`>], `"required"`, `"kind"` \| `"properties"` \| `"host"` \| `"url"` \| `"port"` \| `"quote"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\> = gatewayDatabase \}, ``"required"``, ``"kind"`` \\| ``"endpoint"`` \\| ``"connection"`` \\| ``"connection.kind"`` \\| ``"connection.properties"`` \\| ``"connection.host"`` \\| ``"connection.url"`` \\| ``"connection.port"`` \\| ``"connection.quote"`` \\| ``"connection.instance"`` \\| ``"connection.database"`` \\| ``"connection.readFrom"`` \\| ``"connection.replicaServerId"`` \\| \`connection.properties.$ {string}`>], `"required"`, `"kind"` \| `"endpoint"` \| `"role"` \| `"location"` \| `"connection"` \| `"project"` \| `"engine"` \| `"warehouse"` \| `"connection.kind"` \| `"connection.properties"` \| `"connection.host"` \| `"connection.url"` \| `"connection.port"` \| `"connection.quote"` \| `"connection.instance"` \| `"connection.database"` \| `"connection.readFrom"` \| `"connection.replicaServerId"` \| `connection.properties.${string}` \| `"maxBytesBilled"` \| `"warehouseId"` \| `"statementTimeoutSeconds"`>
`sql.table`	`VObject`<`undefined` \| { `schema`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `name`: `string` }, { `database`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `schema`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `name`: `VString`<`string`, `"required"`> }, `"optional"`, `"name"` \| `"schema"` \| `"database"`>
`sql.receipts`	`VUnion`<`undefined` \| `null` \| { `schema`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `name`: `string` }, [`VObject`<{ `schema`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `name`: `string` }, { `database`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `schema`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `name`: `VString`<`string`, `"required"`> }, `"required"`, `"name"` \| `"schema"` \| `"database"`>, `VNull`<`null`, `"required"`>], `"optional"`, `"name"` \| `"schema"` \| `"database"`>
`sql.changeRecord`	`VUnion`<`undefined` \| `null` \| { `kind`: `"capture"` ; `captureInstance`: `string` } \| { `root`: `undefined` \| `null` \| { properties?: Record<string, string>; port?: number \| null; instance?: string \| null; database?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { properties?: Record<string, string>; kind: “url”; url: string; quote: “double” \| “backtick” \| “bracket”; } \| { kind: “quack”; host: string; port: number; database: string; } ; `kind`: `"logminer"` }, [`VNull`<`null`, `"required"`>, `VObject`<{ `kind`: `"capture"` ; `captureInstance`: `string` }, { `kind`: `VLiteral`<`"capture"`, `"required"`> ; `captureInstance`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"captureInstance"`>, `VObject`<{ `root`: `undefined` \| `null` \| { properties?: Record<string, string>; port?: number \| null; instance?: string \| null; database?: string \| null; readFrom?: “primary” \| “readable_secondary”; replicaServerId?: number \| null; kind: “server”; host: string; } \| { properties?: Record<string, string>; kind: “url”; url: string; quote: “double” \| “backtick” \| “bracket”; } \| { kind: “quack”; host: string; port: number; database: string; } ; `kind`: `"logminer"` }, { `kind`: `VLiteral`<`"logminer"`, `"required"`> ; `root`: `VUnion`<`undefined` \| `null` \| { `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` } \| { `properties`: `undefined` \| `Record`<`string`, `string`> ; `kind`: `"url"` ; `url`: `string` ; `quote`: `"double"` \| `"backtick"` \| `"bracket"` } \| { `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, [`VUnion`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` } \| { `properties`: `undefined` \| `Record`<`string`, `string`> ; `kind`: `"url"` ; `url`: `string` ; `quote`: `"double"` \| `"backtick"` \| `"bracket"` } \| { `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, [`VObject`<{ `properties`: `undefined` \| `Record`<`string`, `string`> ; `port`: `undefined` \| `null` \| `number` ; `instance`: `undefined` \| `null` \| `string` ; `database`: `undefined` \| `null` \| `string` ; `readFrom`: `undefined` \| `"primary"` \| `"readable_secondary"` ; `replicaServerId`: `undefined` \| `null` \| `number` ; `kind`: `"server"` ; `host`: `string` }, { `kind`: `VLiteral`<`"server"`, `"required"`> ; `host`: `VString`<`string`, `"required"`> ; `port`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `instance`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `database`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `readFrom`: `VUnion`<`undefined` \| `"primary"` \| `"readable_secondary"`, [`VLiteral`<`"primary"`, `"required"`>, `VLiteral`<`"readable_secondary"`, `"required"`>], `"optional"`, `never`> ; `replicaServerId`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `properties`: `VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`> }, `"required"`, `"kind"` \| `"properties"` \| `"host"` \| `"port"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `properties`: `undefined` \\| `Record`\<`string`, `string`\> ; `kind`: ``"url"`` ; `url`: `string` ; `quote`: ``"double"`` \\| ``"backtick"`` \\| ``"bracket"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"url"``, ``"required"``\> ; `url`: [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\> ; `quote`: [`VUnion`](/api/classes/values.VUnion)\<``"double"`` \\| ``"backtick"`` \\| ``"bracket"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"double"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"backtick"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"bracket"``, ``"required"``\>], ``"required"``, `never`\> ; `properties`: [`VRecord`](/api/classes/values.VRecord)\<`undefined` \\| `Record`\<`string`, `string`\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, [`VString`](/api/classes/values.VString)\<`string`, ``"required"``\>, ``"optional"``, `string`\> \}, ``"required"``, ``"kind"`` \\| ``"properties"`` \\| ``"url"`` \\| ``"quote"`` \\| \`properties.$ {string}`>, `VObject`<{ `kind`: `"quack"` ; `host`: `string` ; `port`: `number` ; `database`: `string` }, { `kind`: `VLiteral`<`"quack"`, `"required"`> ; `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `database`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"host"` \| `"port"` \| `"database"`>], `"required"`, `"kind"` \| `"properties"` \| `"host"` \| `"url"` \| `"port"` \| `"quote"` \| `"instance"` \| `"database"` \| `"readFrom"` \| `"replicaServerId"` \| `properties. $\{string}\`\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"optional"``, ``"kind"`` \\| ``"properties"`` \\| ``"host"`` \\| ``"url"`` \\| ``"port"`` \\| ``"quote"`` \\| ``"instance"`` \\| ``"database"`` \\| ``"readFrom"`` \\| ``"replicaServerId"`` \\| \`properties.$ {string}`> }, `"required"`, `"kind"` \| `"root"` \| `"root.kind"` \| `"root.properties"` \| `"root.host"` \| `"root.url"` \| `"root.port"` \| `"root.quote"` \| `"root.instance"` \| `"root.database"` \| `"root.readFrom"` \| `"root.replicaServerId"` \| `root.properties. $\{string}\`\>], ``"optional"``, ``"kind"`` \\| ``"root"`` \\| ``"captureInstance"`` \\| ``"root.kind"`` \\| ``"root.properties"`` \\| ``"root.host"`` \\| ``"root.url"`` \\| ``"root.port"`` \\| ``"root.quote"`` \\| ``"root.instance"`` \\| ``"root.database"`` \\| ``"root.readFrom"`` \\| ``"root.replicaServerId"`` \\| \`root.properties.$ {string}`>
`sql.icebergCatalogs`	`VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`>
`sftp`	{ `access`: `VUnion`<`"read"` \| `"write"`, [`VLiteral`<`"read"`, `"required"`>, `VLiteral`<`"write"`, `"required"`>], `"required"`, `never`> ; `connection`: `VObject`<{ `host`: `string` ; `port`: `number` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> }, `"required"`, `"host"` \| `"port"`> ; `directory`: `VString`<`string`, `"required"`> }
`sftp.access`	`VUnion`<`"read"` \| `"write"`, [`VLiteral`<`"read"`, `"required"`>, `VLiteral`<`"write"`, `"required"`>], `"required"`, `never`>
`sftp.connection`	`VObject`<{ `host`: `string` ; `port`: `number` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> }, `"required"`, `"host"` \| `"port"`>
`sftp.directory`	`VString`<`string`, `"required"`>
`git`	{ `repository`: `VString`<`string`, `"required"`> ; `refs`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> }
`git.repository`	`VString`<`string`, `"required"`>
`git.refs`	`VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>
`sheets`	{ `endpoint`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `spreadsheetId`: `VString`<`string`, `"required"`> ; `sheetIds`: `VArray`<`number`[], `VFloat64`<`number`, `"required"`>, `"required"`> }
`sheets.endpoint`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`sheets.spreadsheetId`	`VString`<`string`, `"required"`>
`sheets.sheetIds`	`VArray`<`number`[], `VFloat64`<`number`, `"required"`>, `"required"`>
`odata`	{ `annotationDocuments`: `VArray`<`undefined` \| `string`[], `VString`<`string`, `"required"`>, `"optional"`> ; `serviceUrl`: `VString`<`string`, `"required"`> ; `entitySet`: `VString`<`string`, `"required"`> ; `version`: `VUnion`<`"v2"` \| `"v4"`, [`VLiteral`<`"v2"`, `"required"`>, `VLiteral`<`"v4"`, `"required"`>], `"required"`, `never`> ; `sapClient`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `pageSize`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `tokenEndpoint`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }
`odata.annotationDocuments`	`VArray`<`undefined` \| `string`[], `VString`<`string`, `"required"`>, `"optional"`>
`odata.serviceUrl`	`VString`<`string`, `"required"`>
`odata.entitySet`	`VString`<`string`, `"required"`>
`odata.version`	`VUnion`<`"v2"` \| `"v4"`, [`VLiteral`<`"v2"`, `"required"`>, `VLiteral`<`"v4"`, `"required"`>], `"required"`, `never`>
`odata.sapClient`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`odata.pageSize`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`odata.tokenEndpoint`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`mailbox`	{ `imap`: `VObject`<{ `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `security`: `VUnion`<`"implicit_tls"` \| `"start_tls"` \| `"loopback"`, [`VLiteral`<`"implicit_tls"`, `"required"`>, `VLiteral`<`"start_tls"`, `"required"`>, `VLiteral`<`"loopback"`, `"required"`>], `"required"`, `never`> }, `"required"`, `"host"` \| `"port"` \| `"security"`> = mailEndpoint; `folders`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> ; `smtp`: `VUnion`<`undefined` \| `null` \| { `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, [`VObject`<{ `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `security`: `VUnion`<`"implicit_tls"` \| `"start_tls"` \| `"loopback"`, [`VLiteral`<`"implicit_tls"`, `"required"`>, `VLiteral`<`"start_tls"`, `"required"`>, `VLiteral`<`"loopback"`, `"required"`>], `"required"`, `never`> }, `"required"`, `"host"` \| `"port"` \| `"security"`>, `VNull`<`null`, `"required"`>], `"optional"`, `"host"` \| `"port"` \| `"security"`> }
`mailbox.imap`	`VObject`<{ `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `security`: `VUnion`<`"implicit_tls"` \| `"start_tls"` \| `"loopback"`, [`VLiteral`<`"implicit_tls"`, `"required"`>, `VLiteral`<`"start_tls"`, `"required"`>, `VLiteral`<`"loopback"`, `"required"`>], `"required"`, `never`> }, `"required"`, `"host"` \| `"port"` \| `"security"`>
`mailbox.folders`	`VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>
`mailbox.smtp`	`VUnion`<`undefined` \| `null` \| { `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, [`VObject`<{ `host`: `string` ; `port`: `number` ; `security`: `"implicit_tls"` \| `"start_tls"` \| `"loopback"` }, { `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `security`: `VUnion`<`"implicit_tls"` \| `"start_tls"` \| `"loopback"`, [`VLiteral`<`"implicit_tls"`, `"required"`>, `VLiteral`<`"start_tls"`, `"required"`>, `VLiteral`<`"loopback"`, `"required"`>], `"required"`, `never`> }, `"required"`, `"host"` \| `"port"` \| `"security"`>, `VNull`<`null`, `"required"`>], `"optional"`, `"host"` \| `"port"` \| `"security"`>
`as2`	{ `as2Id`: `VString`<`string`, `"required"`> ; `partnerAs2Id`: `VString`<`string`, `"required"`> ; `partnerUrl`: `VString`<`string`, `"required"`> ; `mdn`: `VUnion`<`"synchronous"` \| `"asynchronous"`, [`VLiteral`<`"synchronous"`, `"required"`>, `VLiteral`<`"asynchronous"`, `"required"`>], `"required"`, `never`> ; `duplicateWindowHours`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }
`as2.as2Id`	`VString`<`string`, `"required"`>
`as2.partnerAs2Id`	`VString`<`string`, `"required"`>
`as2.partnerUrl`	`VString`<`string`, `"required"`>
`as2.mdn`	`VUnion`<`"synchronous"` \| `"asynchronous"`, [`VLiteral`<`"synchronous"`, `"required"`>, `VLiteral`<`"asynchronous"`, `"required"`>], `"required"`, `never`>
`as2.duplicateWindowHours`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`as4`	{ `partyId`: `VString`<`string`, `"required"`> ; `partyIdType`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `partnerPartyId`: `VString`<`string`, `"required"`> ; `partnerPartyIdType`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `partnerUrl`: `VString`<`string`, `"required"`> ; `agreement`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `service`: `VObject`<{ `type`: `undefined` \| `null` \| `string` ; `value`: `string` }, { `value`: `VString`<`string`, `"required"`> ; `type`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }, `"required"`, `"type"` \| `"value"`> ; `action`: `VString`<`string`, `"required"`> ; `messageProperties`: `VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`> ; `duplicateWindowHours`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }
`as4.partyId`	`VString`<`string`, `"required"`>
`as4.partyIdType`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`as4.partnerPartyId`	`VString`<`string`, `"required"`>
`as4.partnerPartyIdType`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`as4.partnerUrl`	`VString`<`string`, `"required"`>
`as4.agreement`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`as4.service`	`VObject`<{ `type`: `undefined` \| `null` \| `string` ; `value`: `string` }, { `value`: `VString`<`string`, `"required"`> ; `type`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }, `"required"`, `"type"` \| `"value"`>
`as4.action`	`VString`<`string`, `"required"`>
`as4.messageProperties`	`VRecord`<`undefined` \| `Record`<`string`, `string`>, `VString`<`string`, `"required"`>, `VString`<`string`, `"required"`>, `"optional"`, `string`>
`as4.duplicateWindowHours`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`oftp2`	{ `odetteId`: `VString`<`string`, `"required"`> ; `partnerOdetteId`: `VString`<`string`, `"required"`> ; `partnerHost`: `VString`<`string`, `"required"`> ; `partnerPort`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `bufferSize`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `credit`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `signedReceipts`: `VUnion`<`undefined` \| `null` \| `boolean`, [`VBoolean`<`boolean`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `duplicateWindowHours`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }
`oftp2.odetteId`	`VString`<`string`, `"required"`>
`oftp2.partnerOdetteId`	`VString`<`string`, `"required"`>
`oftp2.partnerHost`	`VString`<`string`, `"required"`>
`oftp2.partnerPort`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`oftp2.bufferSize`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`oftp2.credit`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`oftp2.signedReceipts`	`VUnion`<`undefined` \| `null` \| `boolean`, [`VBoolean`<`boolean`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`oftp2.duplicateWindowHours`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`mllp`	{ `endpoint`: `VString`<`string`, `"required"`> ; `replyEndpoint`: `VString`<`undefined` \| `string`, `"optional"`> ; `receivingApplication`: `VString`<`string`, `"required"`> ; `receivingFacility`: `VString`<`string`, `"required"`> }
`mllp.endpoint`	`VString`<`string`, `"required"`>
`mllp.replyEndpoint`	`VString`<`undefined` \| `string`, `"optional"`>
`mllp.receivingApplication`	`VString`<`string`, `"required"`>
`mllp.receivingFacility`	`VString`<`string`, `"required"`>
`qbwc`	{ `username`: `VString`<`string`, `"required"`> ; `companyFile`: `VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> ; `runEveryMinutes`: `VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`> }
`qbwc.username`	`VString`<`string`, `"required"`>
`qbwc.companyFile`	`VUnion`<`undefined` \| `null` \| `string`, [`VString`<`string`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`qbwc.runEveryMinutes`	`VUnion`<`undefined` \| `null` \| `number`, [`VFloat64`<`number`, `"required"`>, `VNull`<`null`, `"required"`>], `"optional"`, `never`>
`reckon_hosted`	{ `fileName`: `VString`<`string`, `"required"`> ; `countryVersion`: `VString`<`string`, `"required"`> ; `endpoint`: `VString`<`undefined` \| `string`, `"optional"`> }
`reckon_hosted.fileName`	`VString`<`string`, `"required"`>
`reckon_hosted.countryVersion`	`VString`<`string`, `"required"`>
`reckon_hosted.endpoint`	`VString`<`undefined` \| `string`, `"optional"`>
`postgres`	{ `host`: `VString`<`string`, `"required"`> ; `port`: `VFloat64`<`number`, `"required"`> ; `database`: `VString`<`string`, `"required"`> ; `publication`: `VString`<`string`, `"required"`> ; `relations`: `VRecord`<`Record`<`string`, { `table`: `string` ; `schema`: `string` }>, `VString`<`string`, `"required"`>, `VObject`<{ `table`: `string` ; `schema`: `string` }, { `schema`: `VString`<`string`, `"required"`> ; `table`: `VString`<`string`, `"required"`> }, `"required"`, `"table"` \| `"schema"`>, `"required"`, `string`> }
`postgres.host`	`VString`<`string`, `"required"`>
`postgres.port`	`VFloat64`<`number`, `"required"`>
`postgres.database`	`VString`<`string`, `"required"`>
`postgres.publication`	`VString`<`string`, `"required"`>
`postgres.relations`	`VRecord`<`Record`<`string`, { `table`: `string` ; `schema`: `string` }>, `VString`<`string`, `"required"`>, `VObject`<{ `table`: `string` ; `schema`: `string` }, { `schema`: `VString`<`string`, `"required"`> ; `table`: `VString`<`string`, `"required"`> }, `"required"`, `"table"` \| `"schema"`>, `"required"`, `string`>

providerJourneyCases

• Const providerJourneyCases: ["organizationAdmission", "providerClientBinding", "callbackReplay", "interruptedExchange", "recentAuthentication", "originalSecurityRecovery", "invitationRecipient", "sponsorWithdrawal", "taskCompletion", "domainAmbiguity", "domainAdmissionSeparation"] Executable obligations beyond token admission.

providerJourneyAssertions

• Const providerJourneyAssertions: VArray<{ evidence: string ; passed: boolean ; assertion: string }[], VObject<{ evidence: string ; passed: boolean ; assertion: string }, { assertion: VString<string, "required"> ; passed: VBoolean<boolean, "required"> ; evidence: VString<string, "required"> }, "required", "evidence" | "passed" | "assertion">, "required">

providerCommandResources

• Const providerCommandResources: Object

Type declaration

Name	Type
`uploadInput`	(`input`: { `integration`: { `module`: `string` ; `export`: `string` } ; `command`: `string` ; `args`: `Record`<`string`, `Value`> }) => `Promise`<{ `media`: `MediaRef` ; `expires_at`: `number` } \| `null`>
`workloadEvidence`	(`input`: { `binding`: `string` ; `context`: `Record`<`string`, `Value`> }) => `Promise`<{ `credential_digest`: `string` ; `authority_digest`: `string` }>
`renewWorkload`	(`input`: { `binding`: `string` ; `context`: `Record`<`string`, `Value`> ; `expires_at`: `number` }) => `Promise`<{ `credential_digest`: `string` ; `authority_digest`: `string` ; `expires_at`: `number` }>
`exportWorkload`	(`input`: { `binding`: `string` ; `context`: `Record`<`string`, `Value`> ; `secret?`: `string` ; `export_credential?`: `string` }) => `Promise`<`null`>
`delegateWorkloadExport`	(`input`: { `binding`: `string` ; `context`: `Record`<`string`, `Value`> ; `secret`: `string` ; `expires_at`: `number` }) => `Promise`<`string`>
`requestIdentity`	(`binding`: `string`) => `Promise`<`string`>
`checkResultContract`	(`contract`: `ProviderCommandResultContract`) => `Promise`<{ `kind`: `"available"` } \| { `kind`: `"unavailable"` ; `reason`: `"contractUnavailable"` \| `"contractChanged"` }>
`stateEvidence`	(`binding`: `string`) => `Promise`<`ProviderStateEvidence`>
`sourceEffect`	(`binding`: `string`, `options?`: { `dataset`: `string` }) => `Promise`<`ProviderSourceEffect`>
`model`	(`input`: { `binding`: `string` ; `values`: `Record`<`string`, `Value`> }) => `Promise`<`ModeledProviderConsequence`>
`projection`	(`binding`: `string`) => `Promise`<{ `values`: `Record`<`string`, `Value`> \| `null` }>
`publish`	(`input`: { `binding`: `string` ; `receipt`: `string` }) => `Promise`<`ProviderPublication`>
`exchange`	(`input`: { `binding`: `string` ; `attempt`: `string` ; `kind`: `"send"` \| `"reconcile"` }) => `Promise`<`string`>
`observe`	(`input`: { `binding`: `string` ; `attempt`: `string` ; `job`: `string` ; `kind`: `"send"` \| `"reconcile"` ; `receipt`: `string` \| `null` }) => `Promise`<`ProviderObservation`>
`executionControl`	(`binding`: `string`) => `Promise`<`ProviderExecutionControl`>
`settlement`	(`binding`: `string`) => `Promise`<{ `settlement`: `ProviderExchangeSettlement` }>
`capture`	(`input`: { `subject`: `string` ; `integration`: { `module`: `string` ; `export`: `string` } ; `command`: `string` ; `target?`: `string` \| { `sourceId`: `string` } \| { `bindingId`: `string` } ; `expectedVersion?`: `string` ; `applyBefore?`: `number` ; `release?`: `string` ; `continuation?`: `CommandContinuation` ; `workload?`: `Record`<`string`, `Value`> ; `execution_placement?`: `string` ; `upload_grant?`: `MediaGrant` ; `args`: `Record`<`string`, `Value`> }) => `Promise`<{ `sourceId`: `SourceId` \| `null` ; `binding`: `string` ; `policy`: `ProviderDeliveryPolicy` ; `mode`: `"live"` \| `"held"` ; `ordering`: `ProviderCommandOrdering` \| `null` ; `credential_digest`: `string` \| `null` ; `authority_digest`: `string` \| `null` ; `command_digest`: `string` ; `releaseDigest`: `string` \| `null` }>
`stop`	(`binding`: `string`) => `Promise`<`null`>
`settle`	(`binding`: `string`) => `Promise`<{ `effect`: `"effective"` \| `"ineffective"` }>
`release`	(`binding`: `string`) => `Promise`<`null`>
`revoke`	(`binding`: `string`) => `Promise`<`null`>
`admitDelivery`	(`input`: { `binding`: `string` ; `exchange_field`: `string` ; `publish_field`: `string` ; `protocol_field`: `string` }) => `Promise`<{ `operation`: `string` }>
`wakeDelivery`	(`binding`: `string`) => `Promise`<`null`>
`acknowledgePublication`	(`binding`: `string`, `receipt`: `string`) => `Promise`<`null`>
`cancelDelivery`	(`binding`: `string`) => `Promise`<`null`>
`authorizeInterpretation`	(`binding`: `string`, `revision`: `string`) => `Promise`<`null`>
`delivery`	(`binding`: `string`) => `Promise`<`ProviderDeliveryStatus` \| `null`>

freshnessClocks

• Const freshnessClocks: Readonly<{ snapshot: (table: string) => Readonly<{ table: string ; kind: FreshnessClockKind }> ; coverage: (table: string) => Readonly<{ table: string ; kind: FreshnessClockKind }> ; publication: (table: string) => Readonly<{ table: string ; kind: FreshnessClockKind }> ; observation: (table: string) => Readonly<{ table: string ; kind: FreshnessClockKind }> ; discovery: (table: string) => Readonly<{ table: string ; kind: FreshnessClockKind }> ; verification: (table: string) => Readonly<{ table: string ; kind: FreshnessClockKind }> }>

sourceArtifact

• Const sourceArtifact: VDerived<ResultRef<{ size: number ; file: GenericId<"_storage"> ; sha256: string ; format: string ; sourceEpoch: string ; sourceEvidence: null | string }, "artifact">, "required", never> | VObject<{ reference: string ; kind: "artifact" ; owner: string ; contract: string ; version: string ; digest: string }, { kind: VLiteral<"artifact", "required"> ; owner: VString<string, "required"> | VLiteral<string, "required"> ; reference: VString<string, "required"> ; version: VString<string, "required"> ; digest: VString<string, "required"> ; contract: VLiteral<string, "required"> }, "required", "reference" | "kind" | "owner" | "contract" | "version" | "digest"> & { type: ResultRef<{ size: number ; file: GenericId<"_storage"> ; sha256: string ; format: string ; sourceEpoch: string ; sourceEvidence: null | string }, "artifact"> }

sourcePopulationLayoutValidator

• Const sourcePopulationLayoutValidator: VObject<{ current: string ; recovery: string ; omissions: string[] ; member: "current" | "recovery" }, { current: VString<string, "required"> ; recovery: VString<string, "required"> ; omissions: VArray<string[], VString<string, "required">, "required"> ; member: VUnion<"current" | "recovery", [VLiteral<"current", "required">, VLiteral<"recovery", "required">], "required", never> = validatorSourcePopulationMember }, "required", "current" | "recovery" | "omissions" | "member"> = sourceValidators.SourcePopulationLayout Source-owned physical recovery metadata confers no read authority.

sourceRecordRecoveryValidator

• Const sourceRecordRecoveryValidator: VObject<{ kind: "record" | "population" ; origin: string ; observation: string ; seen: string }, { kind: VUnion<"record" | "population", [VLiteral<"record", "required">, VLiteral<"population", "required">], "required", never> = validatorSourceRecoveryKind; observation: VString<string, "required"> ; origin: VString<string, "required"> ; seen: VString<string, "required"> }, "required", "kind" | "origin" | "observation" | "seen"> = sourceValidators.SourceRecordRecovery

capabilities

• Const capabilities: VObject<{ evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, { consistency: VUnion<"snapshot" | "observations", [VLiteral<"observations", "required">, VLiteral<"snapshot", "required">], "required", never> = validatorSourceConsistency; evidence: VUnion<"native" | "asserted" | "brokered", [VLiteral<"native", "required">, VLiteral<"brokered", "required">, VLiteral<"asserted", "required">], "required", never> = validatorEvidenceClass; recordRefresh: VBoolean<boolean, "required"> ; reconciliation: VBoolean<boolean, "required"> ; notifications: VBoolean<boolean, "required"> ; snapshotMaxRows: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; protocol: Validator<"dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest", "required", any> ; coverage: Validator<"records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", "required", any> ; atomicity: Validator<"record" | "snapshot" | "sourceTransaction", "required", any> ; history: Validator<"observations" | "completeChanges" | "completeOccurrences" | "latestState", "required", any> }, "required", "evidence" | "consistency" | "coverage" | "reconciliation" | "history" | "protocol" | "atomicity" | "recordRefresh" | "notifications" | "snapshotMaxRows" | `coverage.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

{any}`> Not exported: an exported type refers to it.

sourceStatusValidator

• Const sourceStatusValidator: VObject<{ assessment: undefined | { kind: “ready”; next: “none”; } | { kind: “unsupported”; code: “SourceCoherenceUnsupported” | “SourcePopulationUnsupported” | “SourceCompleteVersionNotDataset” | “SourceContinuityUnsupported” | “SourceRequirementUnsupported” | “SourceEvidenceClassUnsupported”; next: “changeRequirement”; } | { kind: “missingEvidence”; code: “ReadServingVersionUnavailable” | “SourceCoherenceUnavailable” | “SourcePopulationCapabilityUnavailable” | “SourcePopulationUnavailable” | … 7 more … | “FreshnessExpired”; next: “requestRefresh” | … 2 more … | “inspectSource”; } ; sourceId: SourceId ; evidence: { dataset?: { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; }; … 11 more …; historyInterrupted: boolean; } ; controls: { pauseId?: PauseId; canRefresh: boolean; } ; sync: null | { status: “blocked” | “scheduled” | “running” | “retrying” | “paused”; cause: “throttled” | “accessRefused” | “credentialRejected” | “credentialExpired” | “scopeMissing” | “signatureRejected” | … 26 more … | null; } }, { sourceId: VIdentity<SourceId, "sourceId", "required"> ; assessment: VUnion<undefined | { kind: "ready" ; next: "none" } | { kind: "unsupported" ; code: "SourceCoherenceUnsupported" | "SourcePopulationUnsupported" | "SourceCompleteVersionNotDataset" | "SourceContinuityUnsupported" | "SourceRequirementUnsupported" | "SourceEvidenceClassUnsupported" ; next: "changeRequirement" } | { kind: "missingEvidence" ; code: "ReadServingVersionUnavailable" | "SourceCoherenceUnavailable" | "SourcePopulationCapabilityUnavailable" | "SourcePopulationUnavailable" | "SourceCompleteVersionUnavailable" | "SourceContinuityUnavailable" | "SourceObservationCoverageRequired" | "SourceObservationUnavailable" | "SourceObservationStale" | "SourceObservationBeforeBarrier" | "FreshnessUnavailable" | "FreshnessExpired" ; next: "requestRefresh" | "wait" | "repairSource" | "inspectSource" }, [VObject<{ kind: "ready" ; next: "none" }, { kind: VLiteral<"ready", "required"> ; next: VLiteral<"none", "required"> = validatorSourceReadyAction }, "required", "kind" | "next">, VObject<{ kind: "unsupported" ; code: "SourceCoherenceUnsupported" | "SourcePopulationUnsupported" | "SourceCompleteVersionNotDataset" | "SourceContinuityUnsupported" | "SourceRequirementUnsupported" | "SourceEvidenceClassUnsupported" ; next: "changeRequirement" }, { kind: VLiteral<"unsupported", "required"> ; code: VUnion<"SourceCoherenceUnsupported" | "SourcePopulationUnsupported" | "SourceCompleteVersionNotDataset" | "SourceContinuityUnsupported" | "SourceRequirementUnsupported" | "SourceEvidenceClassUnsupported", [VLiteral<"SourceCoherenceUnsupported", "required">, VLiteral<"SourcePopulationUnsupported", "required">, VLiteral<"SourceCompleteVersionNotDataset", "required">, VLiteral<"SourceContinuityUnsupported", "required">, VLiteral<"SourceRequirementUnsupported", "required">, VLiteral<"SourceEvidenceClassUnsupported", "required">], "required", never> = validatorSourceUnsupportedCode; next: VLiteral<"changeRequirement", "required"> = validatorSourceUnsupportedAction }, "required", "kind" | "code" | "next">, VObject<{ kind: "missingEvidence" ; code: "ReadServingVersionUnavailable" | "SourceCoherenceUnavailable" | "SourcePopulationCapabilityUnavailable" | "SourcePopulationUnavailable" | "SourceCompleteVersionUnavailable" | "SourceContinuityUnavailable" | "SourceObservationCoverageRequired" | "SourceObservationUnavailable" | "SourceObservationStale" | "SourceObservationBeforeBarrier" | "FreshnessUnavailable" | "FreshnessExpired" ; next: "requestRefresh" | "wait" | "repairSource" | "inspectSource" }, { kind: VLiteral<"missingEvidence", "required"> ; code: VUnion<"ReadServingVersionUnavailable" | "SourceCoherenceUnavailable" | "SourcePopulationCapabilityUnavailable" | "SourcePopulationUnavailable" | "SourceCompleteVersionUnavailable" | "SourceContinuityUnavailable" | "SourceObservationCoverageRequired" | "SourceObservationUnavailable" | "SourceObservationStale" | "SourceObservationBeforeBarrier" | "FreshnessUnavailable" | "FreshnessExpired", [VLiteral<"ReadServingVersionUnavailable", "required">, VLiteral<"SourceCoherenceUnavailable", "required">, VLiteral<"SourcePopulationCapabilityUnavailable", "required">, VLiteral<"SourcePopulationUnavailable", "required">, VLiteral<"SourceCompleteVersionUnavailable", "required">], "required", never> = validatorSourceMissingEvidenceCode; next: VUnion<"requestRefresh" | "wait" | "repairSource" | "inspectSource", [VLiteral<"requestRefresh", "required">, VLiteral<"wait", "required">, VLiteral<"repairSource", "required">, VLiteral<"inspectSource", "required">], "required", never> = validatorSourceEvidenceAction }, "required", "kind" | "code" | "next">], "optional", "kind" | "code" | "next"> ; evidence: VObject<{ dataset: undefined | { component: string | null; dataset: string | null; version: string | null; revision: string | null; publicationId: SourcePublicationId | null; coherent: boolean; completeVersion: boolean; } ; recordObservedFrom: undefined | number ; recordObservedTo: undefined | number ; capabilities: null | { evidence: “native” | “asserted” | “brokered”; consistency: “snapshot” | “observations”; coverage: “records” | “enumeration” | “snapshot” | “queryResult” | “incrementalSnapshot” | “committedPrefix” | “latestPerKey”; … 6 more …; snapshotMaxRows: string | null; } ; population: null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; erased: boolean ; publication: null | { sourceId: SourceId; scope: string; publicationId: SourcePublicationId; checkpoint: { position: { value: string; space: string; } | null; captureId: string; } | null; epoch: SourceEpoch; } ; populationCovered: boolean ; populationObservedFrom: null | number ; observedFrom: null | number ; observedTo: null | number ; continuityLost: boolean ; historyInterrupted: boolean }, { publication: VUnion<null | { sourceId: SourceId ; scope: string ; publicationId: SourcePublicationId ; checkpoint: null | { position: { value: string; space: string; } | null; captureId: string; } ; epoch: SourceEpoch }, [VObject<{ sourceId: SourceId ; scope: string ; publicationId: SourcePublicationId ; checkpoint: null | { position: { value: string; space: string; } | null; captureId: string; } ; epoch: SourceEpoch }, { sourceId: VIdentity<SourceId, "sourceId", "required"> ; epoch: VString<SourceEpoch, "required"> ; scope: VString<string, "required"> ; publicationId: VString<SourcePublicationId, "required"> ; checkpoint: VUnion<null | { position: null | { value: string; space: string; } ; captureId: string }, [VObject<{ position: null | { value: string; space: string; } ; captureId: string }, { captureId: VString<string, "required"> ; position: VUnion<null | { value: string ; space: string }, [VObject<{ value: string ; space: string }, { space: VString<string, "required"> ; value: VString<string, "required"> }, "required", "value" | "space">, VNull<null, "required">], "required", "value" | "space"> }, "required", "position" | "captureId" | "position.value" | "position.space">, VNull<null, "required">], "required", "position" | "captureId" | "position.value" | "position.space"> }, "required", "sourceId" | "scope" | "publicationId" | "checkpoint" | "epoch" | "checkpoint.position" | "checkpoint.captureId" | "checkpoint.position.value" | "checkpoint.position.space">, VNull<null, "required">], "required", "sourceId" | "scope" | "publicationId" | "checkpoint" | "epoch" | "checkpoint.position" | "checkpoint.captureId" | "checkpoint.position.value" | "checkpoint.position.space"> ; populationCovered: VBoolean<boolean, "required"> ; populationObservedFrom: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; observedFrom: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; observedTo: VUnion<null | number, [VFloat64<number, "required">, VNull<null, "required">], "required", never> ; recordObservedFrom: VFloat64<undefined | number, "optional"> ; recordObservedTo: VFloat64<undefined | number, "optional"> ; continuityLost: VBoolean<boolean, "required"> ; historyInterrupted: VBoolean<boolean, "required"> ; erased: VBoolean<boolean, "required"> ; dataset: VObject<undefined | { component: null | string ; dataset: null | string ; version: null | string ; revision: null | string ; publicationId: null | SourcePublicationId ; coherent: boolean ; completeVersion: boolean }, { component: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; dataset: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; version: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; revision: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; publicationId: VUnion<null | SourcePublicationId, [VString<SourcePublicationId, "required">, VNull<null, "required">], "required", never> ; coherent: VBoolean<boolean, "required"> ; completeVersion: VBoolean<boolean, "required"> }, "optional", "component" | "dataset" | "version" | "revision" | "publicationId" | "coherent" | "completeVersion"> ; capabilities: VUnion<null | { evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, [VObject<{ evidence: "native" | "asserted" | "brokered" ; consistency: "snapshot" | "observations" ; coverage: "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey" ; reconciliation: boolean ; history: "observations" | "completeChanges" | "completeOccurrences" | "latestState" ; protocol: "dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest" ; atomicity: "record" | "snapshot" | "sourceTransaction" ; recordRefresh: boolean ; notifications: boolean ; snapshotMaxRows: null | string }, { consistency: VUnion<"snapshot" | "observations", [VLiteral<"observations", "required">, VLiteral<"snapshot", "required">], "required", never> = validatorSourceConsistency; evidence: VUnion<"native" | "asserted" | "brokered", [VLiteral<"native", "required">, VLiteral<"brokered", "required">, VLiteral<"asserted", "required">], "required", never> = validatorEvidenceClass; recordRefresh: VBoolean<boolean, "required"> ; reconciliation: VBoolean<boolean, "required"> ; notifications: VBoolean<boolean, "required"> ; snapshotMaxRows: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; protocol: Validator<"dataset" | "changeFeed" | "recordObservation" | "transactionalFeed" | "streamLatest", "required", any> ; coverage: Validator<"records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", "required", any> ; atomicity: Validator<"record" | "snapshot" | "sourceTransaction", "required", any> ; history: Validator<"observations" | "completeChanges" | "completeOccurrences" | "latestState", "required", any> }, "required", "evidence" | "consistency" | "coverage" | "reconciliation" | "history" | "protocol" | "atomicity" | "recordRefresh" | "notifications" | "snapshotMaxRows" | `coverage.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

{any}`>, VNull<null, "required">], "required", "evidence" | "consistency" | "coverage" | "reconciliation" | "history" | "protocol" | "atomicity" | "recordRefresh" | "notifications" | "snapshotMaxRows" | `coverage.

\{any}\` \| \`history.

{any}` | `protocol.

\{any}\` \| \`atomicity.

{any}`> ; population: VUnion<null | "records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", [Validator<"records" | "enumeration" | "snapshot" | "queryResult" | "incrementalSnapshot" | "committedPrefix" | "latestPerKey", "required", any>, VNull<null, "required">], "required", any> }, "required", "dataset" | "capabilities" | "population" | "erased" | "publication" | "populationCovered" | "populationObservedFrom" | "observedFrom" | "observedTo" | "continuityLost" | "historyInterrupted" | "recordObservedFrom" | "recordObservedTo" | "capabilities.evidence" | "capabilities.consistency" | "capabilities.coverage" | "capabilities.reconciliation" | "capabilities.history" | "capabilities.protocol" | "capabilities.atomicity" | "capabilities.recordRefresh" | "capabilities.notifications" | "capabilities.snapshotMaxRows" | "dataset.component" | "dataset.dataset" | "dataset.version" | "dataset.revision" | "dataset.publicationId" | "dataset.coherent" | "dataset.completeVersion" | "publication.sourceId" | "publication.scope" | "publication.publicationId" | "publication.checkpoint" | "publication.epoch" | "publication.checkpoint.position" | "publication.checkpoint.captureId" | "publication.checkpoint.position.value" | "publication.checkpoint.position.space" | `capabilities.coverage.

\{any}\` \| \`capabilities.history.

{any}` | `capabilities.protocol.

\{any}\` \| \`capabilities.atomicity.

{any}` | `population.

\{any}\`\> ; `controls`: [`VObject`](/api/classes/values.VObject)\<\{ `pauseId`: `undefined` \| [`PauseId`](/api/modules/values#pauseid) ; `canRefresh`: `boolean` \}, \{ `canRefresh`: [`VBoolean`](/api/classes/values.VBoolean)\<`boolean`, ``"required"``\> ; `pauseId`: [`VString`](/api/classes/values.VString)\<`undefined` \| [`PauseId`](/api/modules/values#pauseid), ``"optional"``\> \}, ``"required"``, ``"pauseId"`` \| ``"canRefresh"``\> ; `sync`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| \{ `status`: ``"blocked"`` \| ``"scheduled"`` \| ``"running"`` \| ``"retrying"`` \| ``"paused"`` ; `cause`: ``null`` \| ``"throttled"`` \| ``"accessRefused"`` \| ``"credentialRejected"`` \| ``"credentialExpired"`` \| ``"scopeMissing"`` \| ``"signatureRejected"`` \| ``"credentialInvalid"`` \| ``"connectionRequired"`` \| ``"revocationPending"`` \| ``"providerDisabled"`` \| ``"connectionForbidden"`` \| ``"addressRefused"`` \| ``"providerUnavailable"`` \| ``"engineBusy"`` \| ``"unexpectedStatus"`` \| ``"responseInvalid"`` \| ``"resultInvalid"`` \| ``"reinstallRequired"`` \| ``"definitionChanged"`` \| ``"migrationRequired"`` \| ``"historyLost"`` \| ``"sourceUnsupported"`` \| ``"readRuleRequired"`` \| ``"boundExceeded"`` \| ``"sourceDisabled"`` \| ``"inspectionOnly"`` \| ``"gatewayMismatch"`` \| ``"workFenced"`` \| ``"datasetErasing"`` \| ``"refreshUnsettled"`` \| ``"engineIncompatible"`` \| ``"engineError"`` \}, [[`VObject`](/api/classes/values.VObject)\<\{ `status`: ``"blocked"`` \| ``"scheduled"`` \| ``"running"`` \| ``"retrying"`` \| ``"paused"`` ; `cause`: ``null`` \| ``"throttled"`` \| ``"accessRefused"`` \| ``"credentialRejected"`` \| ``"credentialExpired"`` \| ``"scopeMissing"`` \| ``"signatureRejected"`` \| ``"credentialInvalid"`` \| ``"connectionRequired"`` \| ``"revocationPending"`` \| ``"providerDisabled"`` \| ``"connectionForbidden"`` \| ``"addressRefused"`` \| ``"providerUnavailable"`` \| ``"engineBusy"`` \| ``"unexpectedStatus"`` \| ``"responseInvalid"`` \| ``"resultInvalid"`` \| ``"reinstallRequired"`` \| ``"definitionChanged"`` \| ``"migrationRequired"`` \| ``"historyLost"`` \| ``"sourceUnsupported"`` \| ``"readRuleRequired"`` \| ``"boundExceeded"`` \| ``"sourceDisabled"`` \| ``"inspectionOnly"`` \| ``"gatewayMismatch"`` \| ``"workFenced"`` \| ``"datasetErasing"`` \| ``"refreshUnsettled"`` \| ``"engineIncompatible"`` \| ``"engineError"`` \}, \{ `status`: [`VUnion`](/api/classes/values.VUnion)\<``"blocked"`` \| ``"scheduled"`` \| ``"running"`` \| ``"retrying"`` \| ``"paused"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"scheduled"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"running"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"retrying"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"blocked"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"paused"``, ``"required"``\>], ``"required"``, `never`\> = validatorSourceSyncStatus; `cause`: [`VUnion`](/api/classes/values.VUnion)\<``null`` \| ``"throttled"`` \| ``"accessRefused"`` \| ``"credentialRejected"`` \| ``"credentialExpired"`` \| ``"scopeMissing"`` \| ``"signatureRejected"`` \| ``"credentialInvalid"`` \| ``"connectionRequired"`` \| ``"revocationPending"`` \| ``"providerDisabled"`` \| ``"connectionForbidden"`` \| ``"addressRefused"`` \| ``"providerUnavailable"`` \| ``"engineBusy"`` \| ``"unexpectedStatus"`` \| ``"responseInvalid"`` \| ``"resultInvalid"`` \| ``"reinstallRequired"`` \| ``"definitionChanged"`` \| ``"migrationRequired"`` \| ``"historyLost"`` \| ``"sourceUnsupported"`` \| ``"readRuleRequired"`` \| ``"boundExceeded"`` \| ``"sourceDisabled"`` \| ``"inspectionOnly"`` \| ``"gatewayMismatch"`` \| ``"workFenced"`` \| ``"datasetErasing"`` \| ``"refreshUnsettled"`` \| ``"engineIncompatible"`` \| ``"engineError"``, [[`Validator`](/api/modules/values#validator)\<``"throttled"`` \| ``"accessRefused"`` \| ``"credentialRejected"`` \| ``"credentialExpired"`` \| ``"scopeMissing"`` \| ``"signatureRejected"`` \| ``"credentialInvalid"`` \| ``"connectionRequired"`` \| ``"revocationPending"`` \| ``"providerDisabled"`` \| ``"connectionForbidden"`` \| ``"addressRefused"`` \| ``"providerUnavailable"`` \| ``"engineBusy"`` \| ``"unexpectedStatus"`` \| ``"responseInvalid"`` \| ``"resultInvalid"`` \| ``"reinstallRequired"`` \| ``"definitionChanged"`` \| ``"migrationRequired"`` \| ``"historyLost"`` \| ``"sourceUnsupported"`` \| ``"readRuleRequired"`` \| ``"boundExceeded"`` \| ``"sourceDisabled"`` \| ``"inspectionOnly"`` \| ``"gatewayMismatch"`` \| ``"workFenced"`` \| ``"datasetErasing"`` \| ``"refreshUnsettled"`` \| ``"engineIncompatible"`` \| ``"engineError"``, ``"required"``, `any`\>, [`VNull`](/api/classes/values.VNull)\<``null``, ``"required"``\>], ``"required"``, `any`\> \}, ``"required"``, ``"status"`` \| ``"cause"`` \| \`cause.

{any}`>, VNull<null, "required">], "required", "status" | "cause" | `cause.

\{any}\`\> \}, ``"required"``, ``"sourceId"`` \| ``"evidence"`` \| ``"assessment"`` \| ``"controls"`` \| ``"sync"`` \| ``"evidence.dataset"`` \| ``"evidence.capabilities"`` \| ``"evidence.population"`` \| ``"evidence.erased"`` \| ``"evidence.publication"`` \| ``"evidence.populationCovered"`` \| ``"evidence.populationObservedFrom"`` \| ``"evidence.observedFrom"`` \| ``"evidence.observedTo"`` \| ``"evidence.continuityLost"`` \| ``"evidence.historyInterrupted"`` \| ``"evidence.recordObservedFrom"`` \| ``"evidence.recordObservedTo"`` \| ``"evidence.capabilities.evidence"`` \| ``"evidence.capabilities.consistency"`` \| ``"evidence.capabilities.coverage"`` \| ``"evidence.capabilities.reconciliation"`` \| ``"evidence.capabilities.history"`` \| ``"evidence.capabilities.protocol"`` \| ``"evidence.capabilities.atomicity"`` \| ``"evidence.capabilities.recordRefresh"`` \| ``"evidence.capabilities.notifications"`` \| ``"evidence.capabilities.snapshotMaxRows"`` \| ``"evidence.dataset.component"`` \| ``"evidence.dataset.dataset"`` \| ``"evidence.dataset.version"`` \| ``"evidence.dataset.revision"`` \| ``"evidence.dataset.publicationId"`` \| ``"evidence.dataset.coherent"`` \| ``"evidence.dataset.completeVersion"`` \| ``"evidence.publication.sourceId"`` \| ``"evidence.publication.scope"`` \| ``"evidence.publication.publicationId"`` \| ``"evidence.publication.checkpoint"`` \| ``"evidence.publication.epoch"`` \| ``"evidence.publication.checkpoint.position"`` \| ``"evidence.publication.checkpoint.captureId"`` \| ``"evidence.publication.checkpoint.position.value"`` \| ``"evidence.publication.checkpoint.position.space"`` \| ``"assessment.kind"`` \| ``"assessment.code"`` \| ``"assessment.next"`` \| ``"controls.pauseId"`` \| ``"controls.canRefresh"`` \| ``"sync.status"`` \| ``"sync.cause"`` \| \`evidence.capabilities.coverage.

{any}` | `evidence.capabilities.history.

\{any}\` \| \`evidence.capabilities.protocol.

{any}` | `evidence.capabilities.atomicity.

\{any}\` \| \`evidence.population.

{any}` | `sync.cause.${any}`>

sourceUnsupportedCodes

• Const sourceUnsupportedCodes: readonly ("SourceCoherenceUnsupported" | "SourcePopulationUnsupported" | "SourceCompleteVersionNotDataset" | "SourceContinuityUnsupported" | "SourceRequirementUnsupported" | "SourceEvidenceClassUnsupported")[] Codes for a requirement the source contract cannot establish; another refresh cannot change them. Mirrors ReadRefusal::unsupported in crates/common/src/schemas/source/read.rs.

sourceMissingEvidenceCodes

• Const sourceMissingEvidenceCodes: readonly ("ReadServingVersionUnavailable" | "SourceCoherenceUnavailable" | "SourcePopulationCapabilityUnavailable" | "SourcePopulationUnavailable" | "SourceCompleteVersionUnavailable" | "SourceContinuityUnavailable" | "SourceObservationCoverageRequired" | "SourceObservationUnavailable" | "SourceObservationStale" | "SourceObservationBeforeBarrier" | "FreshnessUnavailable" | "FreshnessExpired")[] Codes for evidence the source does not currently hold. Mirrors every other ReadRefusal in crates/common/src/schemas/source/read.rs.

sourceRefreshRequestValidator

• Const sourceRefreshRequestValidator: VObject<{ kind: "sourceRefresh" ; sourceId: SourceId ; requestId: RequestId ; outcome: "requested" | "joined" ; recoverUntil: number }, { kind: VLiteral<"sourceRefresh", "required"> ; requestId: VIdentity<RequestId, "requestId", "required"> ; sourceId: VIdentity<SourceId, "sourceId", "required"> ; outcome: VUnion<"requested" | "joined", [VLiteral<"requested", "required">, VLiteral<"joined", "required">], "required", never> ; recoverUntil: VFloat64<number, "required"> }, "required", "kind" | "sourceId" | "requestId" | "outcome" | "recoverUntil"> Immutable acceptance. Progress never changes this request or its original source.

sourceRefreshObservationValidator

• Const sourceRefreshObservationValidator: VUnion<{ reason: null ; request: { kind: “sourceRefresh”; sourceId: SourceId; requestId: RequestId; outcome: “requested” | “joined”; recoverUntil: number; } ; publicationId: null | SourcePublicationId ; phase: "completed" | "pending" } | { reason: SourceRequestIssue ; request: { kind: “sourceRefresh”; sourceId: SourceId; requestId: RequestId; outcome: “requested” | “joined”; recoverUntil: number; } ; publicationId: null | SourcePublicationId ; phase: "unavailable" | "blocked" }, (VObject<{ reason: null ; request: { kind: “sourceRefresh”; sourceId: SourceId; requestId: RequestId; outcome: “requested” | “joined”; recoverUntil: number; } ; publicationId: null | SourcePublicationId ; phase: "completed" | "pending" }, { request: VObject<{ kind: "sourceRefresh" ; sourceId: SourceId ; requestId: RequestId ; outcome: "requested" | "joined" ; recoverUntil: number }, { kind: VLiteral<"sourceRefresh", "required"> ; requestId: VIdentity<RequestId, "requestId", "required"> ; sourceId: VIdentity<SourceId, "sourceId", "required"> ; outcome: VUnion<"requested" | "joined", [VLiteral<"requested", "required">, VLiteral<"joined", "required">], "required", never> ; recoverUntil: VFloat64<number, "required"> }, "required", "kind" | "sourceId" | "requestId" | "outcome" | "recoverUntil"> = sourceRefreshRequestValidator; phase: VLiteral<"completed" | "pending", "required"> ; publicationId: VUnion<null | SourcePublicationId, [VString<SourcePublicationId, "required">, VNull<null, "required">], "required", never> ; reason: VNull<null, "required"> }, "required", "reason" | "request" | "publicationId" | "phase" | "request.kind" | "request.sourceId" | "request.requestId" | "request.outcome" | "request.recoverUntil"> | VObject<{ reason: SourceRequestIssue ; request: { kind: “sourceRefresh”; sourceId: SourceId; requestId: RequestId; outcome: “requested” | “joined”; recoverUntil: number; } ; publicationId: null | SourcePublicationId ; phase: "unavailable" | "blocked" }, { request: VObject<{ kind: "sourceRefresh" ; sourceId: SourceId ; requestId: RequestId ; outcome: "requested" | "joined" ; recoverUntil: number }, { kind: VLiteral<"sourceRefresh", "required"> ; requestId: VIdentity<RequestId, "requestId", "required"> ; sourceId: VIdentity<SourceId, "sourceId", "required"> ; outcome: VUnion<"requested" | "joined", [VLiteral<"requested", "required">, VLiteral<"joined", "required">], "required", never> ; recoverUntil: VFloat64<number, "required"> }, "required", "kind" | "sourceId" | "requestId" | "outcome" | "recoverUntil"> = sourceRefreshRequestValidator; phase: VLiteral<"unavailable" | "blocked", "required"> ; publicationId: VUnion<null | SourcePublicationId, [VString<SourcePublicationId, "required">, VNull<null, "required">], "required", never> ; reason: Validator<SourceRequestIssue, "required", any> = sourceRequestIssueValidator }, "required", "reason" | "request" | "publicationId" | "phase" | "request.kind" | "request.sourceId" | "request.requestId" | "request.outcome" | "request.recoverUntil" | `reason.

\{any}\`\>)[], ``"required"``, ``"reason"`` \| ``"request"`` \| ``"publicationId"`` \| ``"phase"`` \| ``"request.kind"`` \| ``"request.sourceId"`` \| ``"request.requestId"`` \| ``"request.outcome"`` \| ``"request.recoverUntil"`` \| \`reason.

{any}`>

syncedTableSource

• Const syncedTableSource: typeof syncedTableSource Component-owned source adapters reuse native table owners.

resultErrorCodes

• Const resultErrorCodes: ["invalid_reply", "result_not_current", "outcome_unknown", "authority_changed", "invalid_argument", "invalid_binding", "result_unavailable", "request_unavailable", "request_expired", "result_mismatch", "result_cancelled", "pushdown_refused", "placement_unsupported", "recovery_unsupported", "contract_refused", "cardinality_exceeded", "arithmetic_error", "resource_limit_exceeded", "local_evaluation_limit", "spill_failed", "result_limit_exceeded", "source_outcome_unknown", "request_mismatch", "result_expired", "request_closed", "result_not_ready", "result_not_current", "capacity_exceeded", "access_denied", "access_changed", "definition_changed", "cursor_mismatch", "source_failed", "source_format_mismatch", "invalid_definition", "schema_mismatch", "source_freshness_unavailable", "input_basis_unavailable", "provider_error"] Not exported: an exported type refers to it.

RESULT_RETAINED_LIMITS

• Const RESULT_RETAINED_LIMITS: Readonly<{ max_rows: 10000000 = 10000000; max_bytes: 10737418240 = 10737418240 }> = QUERY_LIMITS.retained Maximum complete retained result. Pages and one-shot replies keep their smaller independent bounds; encoded kept files are bounded separately.

Functions

defineConnection

▸ defineConnection(options): HttpConnectionRef Portable connection requirement. The deployment variable selects an admitted immutable connection, never a URL or credential. This grants no authority. Retained invocations capture the original connection identity.

Parameters

Name	Type
`options`	`Object`
`options.provider`	`HttpProvider`
`options.connection`	`DeploymentValue`
`options.policy`	`FunctionReference`<`"query"`, `"internal"`, `ConnectionRequest`, `boolean`>

Returns

HttpConnectionRef

connectionAccountStatus

▸ connectionAccountStatus(account): Promise<ConnectionStatus | null> Read the account in this executing component under the current caller. No supplied component or actor can retarget its authority.

Parameters

Name	Type
`account`	`Object`
`account.integration`	`Object`
`account.integration.module`	`string`
`account.integration.export`	`string`
`account.owner?`	`"personal"` \| `"organization"`
`account.organization?`	`string` \| `null`
`account.accountHandle`	`string`

Returns

Promise<ConnectionStatus | null>

browser

▸ browser<I, R>(contract, run): BrowserImplementation<I, R> Run an async callback in the retained integration isolate. Native custody performs each admitted browser command and the declared final capture.

Type parameters

Name	Type
`I`	`I`
`R`	extends `Record`<`string`, `BrowserAddress`> = {}

Parameters

Name	Type
`contract`	`BrowserContract`<`R`>
`run`	(`page`: `BrowserPage`<keyof `R` & `string`>, `input`: `I`) => `Promise`<`void`>

Returns

BrowserImplementation<I, R>

defineBrowserResource

▸ defineBrowserResource<S, C>(options): BrowserResourceReference<ObjectType<S>, C> A component supplies infrastructure lifecycle through ordinary generated references. The native binder configures its private provider resource. Installing it allocates nothing. confinement states what the provider’s isolation actually enforces. A binding accepts an unenforced capability only by declaring it.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `GenericValidator`>
`C`	extends `BrowserConfinement` = `"enforced"`

Parameters

Name	Type
`options`	`Object`
`options.setup`	`S`
`options.installation`	`string`
`options.confinement?`	`C`

Returns

BrowserResourceReference<ObjectType<S>, C>

capturedVirtualTableTargets

▸ capturedVirtualTableTargets<Fields, Engine, Target>(schema, captures, engine): Object An environment mapping requires an explicit selection before it is a source.

Type parameters

Name	Type
`Fields`	extends `PropertyValidators`
`Engine`	extends `VirtualTableEngine`
`Target`	extends `string`

Parameters

Name	Type
`schema`	`Fields`
`captures`	`Record`<`Target`, `CapturedRemoteSchema`>
`engine`	`Engine`

Returns

Object

Name	Type
`forTarget`	(`target`: `Target`) => `CapturedVirtualTable`<`Fields`, `Engine`>

connectedMcpExchange

▸ connectedMcpExchange(integration, input): Promise<ConnectedMcpResponse> One exchange with the MCP server an account integration connects to, in an action, as its caller and with the caller’s connected account. Native custody holds the server’s address and the account’s credential and checks the account’s current use authority; neither the address nor the credential enters the action. A refused account answers the same connection requirement ctx.connections.require does.

Parameters

Name	Type
`integration`	`ConnectionIntegration`
`input`	`Object`
`input.scope`	`ConnectionScope`
`input.account`	`string`
`input.request`	`ConnectedMcpRequest`

Returns

Promise<ConnectedMcpResponse>

setupPattern

▸ setupPattern(pattern): RegExp Compile a declared pattern the one way both sides compile it: anchored whole, never partially matched.

Parameters

Name	Type
`pattern`	`string`

Returns

RegExp

checkSetupValue

▸ checkSetupValue(field, value): SetupRefusal | undefined Check one supplied value against one field. undefined is admitted. The same rules the backend applies, in the same order, so a form that says “that is not a subdomain” and a server that refuses the request are saying the same thing. It never decides anything: the backend re-checks every value it is given.

Parameters

Name	Type
`field`	`SetupField`
`value`	`string`

Returns

SetupRefusal | undefined

renderSetupBaseUrl

▸ renderSetupBaseUrl(field, value): string The address a base_url field renders.

Parameters

Name	Type
`field`	`SetupField`
`value`	`string`

Returns

string

describeSetupRefusal

▸ describeSetupRefusal(refusal): string Say why a value was refused, in one line, for a form or a prompt.

Parameters

Name	Type
`refusal`	`SetupRefusal`

Returns

string

setupFieldsToAsk

▸ setupFieldsToAsk(requirements): SetupRequirement[] The fields a person still has to answer, in declaration order. Secrets are not among them: they are provisioned through the credential path, and a form that rendered an input for one would be inviting a secret into a request that has no business carrying it. An already configured administrator field is not among them either — that is the whole point of the configured flag.

Parameters

Name	Type
`requirements`	readonly `SetupRequirement`[]

Returns

SetupRequirement[]

accountSetupFields

▸ accountSetupFields(requirements): SetupRequirement[] The fields a CONNECTING ACCOUNT answers, in declaration order. An account connecting its own installation answers what its own installation decides — its instance, its region, its workspace — and nothing about the deployment. An administrator field is deployment configuration: the person consenting has no way to know it, the deployment already states it, and the backend refuses it from this direction by name. Filtering it out here is what keeps a consent screen from asking a customer to configure somebody else’s deployment; the backend still decides.

Parameters

Name	Type
`requirements`	readonly `SetupRequirement`[]

Returns

SetupRequirement[]

connectionSetupSchema

▸ connectionSetupSchema<T>(transport): NativeSetupFor<T> The admitted setting shape of a native transport; this supplies no credentials.

Type parameters

Name	Type
`T`	extends { `kind`: `string` } \| { `transport`: `string` }

Parameters

Name	Type
`transport`	`T`

Returns

NativeSetupFor<T>

datasetSourceCollection

▸ datasetSourceCollection<S, Scope, Contract>(table): Object The dataset compiler consumes the same collection and policy as a synced table. This descriptor names a source; it does not install or acquire it.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `GenericValidator`>
`Scope`	extends `Record`<`string`, `Value`>
`Contract`	`Contract`

Parameters

Name	Type
`table`	`ResourceTable`<`S`, `Scope`, `Contract`>

Returns

Object

Name	Type
`schema`	`S`
`binding`	`SourceBinding`
`access`	`SerializedReadAccess`

isResourceTable

▸ isResourceTable(value): value is ResourceTable<Record<string, GenericValidator>, Object, any>

Parameters

Name	Type
`value`	`unknown`

Returns

value is ResourceTable<Record<string, GenericValidator>, Object, any>

defineSyncedTable

▸ defineSyncedTable<Row>(definition): PublishedDefinition<Row> Declare a native representation maintained by its one source owner. Imports start no work and confer no authority.

Type parameters

Name	Type
`Row`	extends `Validator`<`Record`<`string`, `any`>, `"required"`, `any`>

Parameters

Name	Type
`definition`	`Object`
`definition.source`	`OutputDefinition`<`Row`>

Returns

PublishedDefinition<Row> ▸ defineSyncedTable<S>(definition): SourceTableDefinition<S, {}>

Type parameters

Name	Type
`S`	extends `SourceHandle`<`any`, `any`, `any`> \| `ResourceTable`<`any`, `any`, `any`>

Parameters

Name	Type
`definition`	`Object`
`definition.source`	`S`
`definition.read?`	`SourceReadRequirement`

Returns

SourceTableDefinition<S, {}>

defineProviderJourneys

▸ defineProviderJourneys(input): Object Execute installed fixture owners, record their native source identities, and run the cleanup owner on every exit. No endpoint accepts reported test results or caller-selected provenance. Hosted qualification belongs to Atlas; controlled and emulator diagnostics cannot claim live-provider evidence. Fixture setup and cleanup must be idempotent on runId, including interrupted setup; each case must use only that run’s isolated resources.

Parameters

Name	Type
`input`	`Object`
`input.module`	`string`
`input.service`	`string`
`input.provenance`	`"controlled"` \| `"emulator"`
`input.setup`	`FunctionReference`<`"action"`, `"internal"`, { `runId`: `string` }, { `fixture`: `string` }>
`input.cleanup`	`FunctionReference`<`"action"`, `"internal"`, { `runId`: `string` ; `fixture`: `string` \| `null` }, `null`>
`input.cases`	`Partial`<`Record`<`CaseName`, `CaseReference`>>

Returns

Object

Name	Type
`functions`	{ `authorize`: `RegisteredQuery`<`"internal"`, {}, `Promise`<`null`>> }
`functions.authorize`	`RegisteredQuery`<`"internal"`, {}, `Promise`<`null`>>
`run`	{ `isBijectionFunction`: `true` ; `isAction`: `true` } & { `_visibility`: `"public"` } & { `isPublic`: `true` } & { `exportCapabilities`: () => `string` }
`cleanup`	{ `isBijectionFunction`: `true` ; `isAction`: `true` } & { `_visibility`: `"public"` } & { `isPublic`: `true` } & { `exportCapabilities`: () => `string` }
`definitionDigest`	`string`

providerTransportFunctions

▸ providerTransportFunctions(options?): Object Export these internal functions from an application module and bind their generated references to the provider delivery component. Each call derives authority from the actual retained component record or Worker; the delivery argument is correlation only.

Parameters

Name	Type
`options?`	`Object`
`options.commands?`	readonly { `integration`: { `module`: `string` ; `export`: `string` } ; `command`: `string` }[]
`options.media?`	readonly `MediaResolver`<`any`>[]
`options.uploadHolder?`	`FunctionReference`<`"mutation"`, `any`>

Returns

Object

Name	Type
`capture`	`RegisteredMutation`<`"internal"`, { `subject`: `string` ; `request`: { target?: string \| { sourceId: string; } \| { bindingId: string; }; workload?: Record<string, any>; release?: string; expectedVersion?: string; continuation?: { kind: “personal”; } \| { kind: “organization”; service: string; credential: string; expiresAt: number; }; … 4 more …; command: string; } ; `delivery`: `string` }, `Promise`<{ `sourceId`: `null` \| `SourceId` ; `binding`: `string` ; `policy`: `Readonly`<{ `reconcilable`: `boolean` ; `sendUntil`: `number` ; `inspectUntil`: `number` ; `maxAttempts`: `number` ; `attemptMs`: `number` }> ; `mode`: `"held"` \| `"live"` ; `ordering`: `null` \| `Readonly`<{ `domain`: `string` ; `mode`: `"latest"` \| `"shared"` \| `"exclusive"` }> ; `credential_digest`: `null` \| `string` ; `authority_digest`: `null` \| `string` ; `command_digest`: `string` ; `releaseDigest`: `null` \| `string` }>>
`exchange`	`RegisteredAction`<`"internal"`, { `kind`: `"send"` \| `"reconcile"` ; `evidence`: `null` \| `string` ; `delivery`: `string` ; `binding`: `string` ; `guard`: `null` \| `string` ; `attempt`: `string` }, `Promise`<`string`>>
`verify`	`RegisteredQuery`<`"internal"`, { `request`: { kind: “state”; delivery: string; binding: string; } \| { dataset?: string; kind: “source_effect”; delivery: string; binding: string; } \| { kind: “settlement”; delivery: string; binding: string; } \| { kind: “control”; delivery: string; binding: string; } \| { kind: “request_identity”; delivery: string; binding: string; } \| { kind: “delivery”; delivery: string; binding: string; } \| { kind: “send” \| “reconcile”; delivery: string; binding: string; receipt: string \| null; attempt: string; job: string; } }, `Promise`<`ProviderStateEvidence`> \| `Promise`<`ProviderSourceEffect`> \| `Promise`<`Readonly`<{ `hasCancellation`: `boolean` ; `termination`: `"unknown"` \| `"stopped"` ; `fileUploadStopped?`: `boolean` }>> \| `Promise`<{ `settlement`: `ProviderExchangeSettlement` }> \| `Promise`<{ `requestIdentity`: `string` }> \| `Promise`<{ `delivery`: `null` \| `Readonly`<{ `operation`: `string` ; `custody`: `"unknown"` \| `"pending"` \| `"held"` \| `"settled"` \| `"withdrawn"` ; `evidence`: `null` \| `"refused"` \| `"applied"` \| `"duplicated"` \| `"not_applied"` ; `refusal`: `null` \| `string` ; `generation`: `number` ; `publication`: `"none"` \| `"blocked"` \| `"pending"` \| `"cancelled"` \| `"published"` ; `interpretation`: `null` \| `"mismatch"` \| `"authorized"` }> }>>
`publish`	`RegisteredAction`<`"internal"`, { `delivery`: `string` ; `binding`: `string` ; `receipt`: `string` }, `Promise`<{ `kind`: `"pending"` \| `"complete"` ; `record`: `null` \| `PublishedSourceRecord` ; `processResult`: `null` \| { `file`: `string` ; `sha256`: `string` ; `bytes`: `number` ; `programDigest`: `string` ; `inputDigest`: `string` ; `definition`: `string` ; `command`: `null` \| { `component`: `null` \| `string` ; `integration`: { `module`: `string` ; `export`: `string` } ; `command`: `string` ; `validator`: `ValidatorJSON` ; `path`: `string`[] } } ; `commandResult`: `null` \| { `file`: `string` ; `sha256`: `string` ; `bytes`: `number` ; `programDigest`: `string` ; `inputDigest`: `string` ; `definition`: `string` ; `command`: `null` \| { `component`: `null` \| `string` ; `integration`: { `module`: `string` ; `export`: `string` } ; `command`: `string` ; `validator`: `ValidatorJSON` ; `path`: `string`[] } } }>>
`model`	`RegisteredMutation`<`"internal"`, { `request`: { kind: “projection”; } \| { kind: “apply”; values: Record<string, any>; } ; `delivery`: `string` ; `binding`: `string` }, `Promise`<{ `kind`: `"modeled"` ; `capture`: `string` } \| { `kind`: `"unavailable"` ; `reason`: `string` } \| { `kind`: `"refused"` ; `capture`: `string` ; `reason`: `string` } \| { `values`: `null` \| `Record`<`string`, `Value`> ; `kind`: `"projection"` }>>
`retainResult`	`RegisteredMutation`<`"internal"`, { `file`: `FileRef` ; `expires_at`: `number` }, `Promise`<`null`>>
`release`	`RegisteredMutation`<`"internal"`, { `fields`: `undefined` \| { publish: string; exchange: string; protocol: string; } ; `revision`: `undefined` \| `string` ; `expires_at`: `undefined` \| `number` ; `receipt`: `undefined` \| `string` ; `context`: `undefined` \| `Record`<`string`, `any`> ; `delivery`: `string` ; `binding`: `string` ; `mode`: `"admit"` \| `"revoke"` \| `"interpret"` \| `"release"` \| `"cancel"` \| `"stop"` \| `"renew"` \| `"settle"` \| `"wake"` \| `"acknowledgePublication"` }, `Promise`<`null`> \| `Promise`<{ `credential_digest`: `string` ; `authority_digest`: `string` ; `expires_at`: `number` }> \| `Promise`<{ `effect`: `"effective"` \| `"ineffective"` }> \| `Promise`<{ `operation`: `string` }>>

recordSource

▸ recordSource<S, Contract>(observation, input): ResourceTable<S, {}, Contract> Declare one producer-owned record collection independently of storage. Feed it to defineTable for operational rows and/or defineDataset for direct lake publication. Both consume this exact source identity; each storage owner retains its own publication receipts and current permissions. The declaration itself installs no native serving table.

Type parameters

Name	Type
`S`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"records"`, `Contract`>
`input`	`Object`
`input.name?`	`string`
`input.access`	`ReadAccess`

Returns

ResourceTable<S, {}, Contract>

materialize

▸ materialize<S, Contract>(observation, input?): SourceTableDefinition<SourceHandle<S, {}, Contract>, {}>

Type parameters

Name	Type
`S`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"records"`, `Contract`>
`input?`	`Object`
`input.name?`	`string`
`input.require?`	`SourceReadRequirement`

Returns

SourceTableDefinition<SourceHandle<S, {}, Contract>, {}>

latest

▸ latest<S, Contract>(observation, input): SourceTableDefinition<SourceHandle<S, {}, Contract>>

Type parameters

Name	Type
`S`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"occurrences"`, `Contract`>
`input`	`LatestSelection`<`NoInfer`<`S`>> & { `schema?`: `never` }

Returns

SourceTableDefinition<SourceHandle<S, {}, Contract>> ▸ latest<S, Output, Contract>(observation, input): SourceTableDefinition<SourceHandle<Output, {}, Contract>>

Type parameters

Name	Type
`S`	extends `Fields`
`Output`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"occurrences"`, `Contract`>
`input`	`LatestSelection`<`NoInfer`<`S`>, `NoInfer`<`Output`>> & { `schema`: `Output` }

Returns

SourceTableDefinition<SourceHandle<Output, {}, Contract>>

fold

▸ fold<S, Output, Contract, Key>(observation, input): SourceTableDefinition<SourceHandle<Output, {}, Contract>> Accumulate accepted occurrences in local capture order. The initial state starts at this installation’s capture boundary and promises no prior history. The pure reducer runs for every accepted event, independently of publication.

Type parameters

Name	Type
`S`	extends `Fields`
`Output`	extends `Fields`
`Contract`	`Contract`
`Key`	extends keyof `S` & keyof `Output` & `string`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"occurrences"`, `Contract`>
`input`	`Object`
`input.name`	`string`
`input.schema`	`Output`
`input.key`	readonly `Key`[]
`input.order`	`"capture"` \| `"providerPartition"`
`input.initial`	`Omit`<`ObjectType`<`Output`>, `Key`>
`input.reduce`	(`q`: `FilterBuilder`<{ `document`: { `state`: `ObjectType`<`Output`> ; `event`: `ObjectType`<`S`> } ; `fieldPaths`: `string` ; `indexes`: {} ; `searchIndexes`: {} ; `vectorIndexes`: {} }>) => { [K in keyof Omit<ObjectType<Output>, Key>]: ExpressionOrValue<ObjectType<Output>[K & keyof ObjectType<Output>]> }
`input.publishEvery`	`SyncEvery`

Returns

SourceTableDefinition<SourceHandle<Output, {}, Contract>>

history

▸ history<S, Contract>(observation, retention?): Readonly<{ kind: "history" ; observation: ObservationHandle<S, "occurrences", Contract> ; retention: Readonly<{ version?: number ; retentionDays?: number }> = selected }>

Type parameters

Name	Type
`S`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"occurrences"`, `Contract`>
`retention`	`EventHistory`

Returns

Readonly<{ kind: "history" ; observation: ObservationHandle<S, "occurrences", Contract> ; retention: Readonly<{ version?: number ; retentionDays?: number }> = selected }>

retainVersions

▸ retainVersions<S, Contract>(observation, input): SourceTableDefinition<SourceHandle<S & { acquired_at: VString<string, "required"> ; expires_at: VString<string, "required"> ; representation: VString<string, "required"> }, {}, Contract>, {}> Retain each immutable file version its records observation acquires, with its protected content, for a finite window. Rows add acquired_at, expires_at and representation; an expired version is removed with its hold. The resource’s own records and current copy are unaffected.

Type parameters

Name	Type
`S`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"records"` \| `"artifacts"`, `Contract`>
`input`	`Object`
`input.retainFor`	`VersionRetention`
`input.name?`	`string`

Returns

SourceTableDefinition<SourceHandle<S & { acquired_at: VString<string, "required"> ; expires_at: VString<string, "required"> ; representation: VString<string, "required"> }, {}, Contract>, {}>

current

▸ current<Observations, Snapshot, Changes>(composition, input): SourceTableDefinition<SourceHandle<SchemaOf<Observations[Snapshot]>, {}, ContractOf<Observations[Snapshot]>>> The current state of a composed resource’s entities: its snapshot part’s records and every later change from its change part, both ordered by one required int64 field and identified by one required text field. The newer of a snapshot record and a change wins; a change whose removed field is true withdraws its record. A snapshot’s absence never removes a record. Bind the composition with bindComposition.

Type parameters

Name	Type
`Observations`	extends `Record`<`string`, `ObservationHandle`<`any`, `any`, `any`>>
`Snapshot`	extends keyof `Observations` & `string`
`Changes`	extends keyof `Observations` & `string`

Parameters

Name	Type
`composition`	`Object`
`composition.isComposition`	`true`
`composition.observations`	`Observations`
`input`	`Object`
`input.snapshot`	`Snapshot`
`input.changes`	`Changes`
`input.key`	keyof `SchemaOf`<`Observations`[`Snapshot`]> & `string`
`input.order`	keyof `SchemaOf`<`Observations`[`Snapshot`]> & `string`
`input.removed?`	keyof `SchemaOf`<`Observations`[`Changes`]> & `string`
`input.publishEvery`	`SyncEvery`
`input.name?`	`string`

Returns

SourceTableDefinition<SourceHandle<SchemaOf<Observations[Snapshot]>, {}, ContractOf<Observations[Snapshot]>>>

retainedTable

▸ retainedTable<Storage>(definition): RetainedTableResource<Storage> & RetainedAccessBinding<Storage> & RetainedInterfaceMembership<Storage> Keep derived values and their source-read obligations in local custody. by names one to four containers: _id, or top-level fields leading active ordinary indexes. Derived keys name one container; registered keys are component-created identities. Native admission remains authoritative.

Type parameters

Name	Type
`Storage`	extends `StorageTable`

Parameters

Name	Type
`definition`	`Object`
`definition.storage`	`LocalStorage`<`Storage`>
`definition.by`	`string` \| readonly `string`[]
`definition.keys?`	`"registered"` \| `"derived"`

Returns

RetainedTableResource<Storage> & RetainedAccessBinding<Storage> & RetainedInterfaceMembership<Storage>

datasetSourceTable

▸ datasetSourceTable<T>(definition): Object Component boundary for source-derived datasets; naming never grants read authority.

Type parameters

Name	Type
`T`	extends `TableDefinition`<`any`, `any`, `any`, `any`, `any`, `any`>

Parameters

Name	Type
`definition`	`T`

Returns

Object

Name	Type
`name`	`string`
`validator`	`T`[`"validator"`]

defineSourceArtifactResultOwner

▸ defineSourceArtifactResultOwner(options): Object Export the returned installation from an application source module. Native discovery registers its existing report result namespace. authorize must use the application’s current source policy and reject an obsolete sourceEpoch. Grant creation also checks the real admitted record attachment; its serialized locator is no grant.

Parameters

Name	Type
`options`	`Object`
`options.owner`	`string`
`options.sourceEvidence?`	(`ctx`: `Parameters`<`ResultOwner`[`"describe"`]>[`0`], `source`: `string`, `sourceEpoch`: `string`, `locator`: `AttachmentLocator`) => `Promise`<`string`>
`options.authorize`	`ResultOwner`[`"describe"`] extends (`ctx`: infer Q, …`args`: `any`[]) => `any` ? (`ctx`: `Q`, `source`: `string`, `sourceEpoch`: `string`) => `Promise`<`void`> : `never`

Returns

Object

Name	Type
`owner`	`ResultOwner`<`Q`, `M`>
`reference`	(`ctx`: `Parameters`<`ResultOwner`[`"describe"`]>[`0`], `source`: `string`, `sourceEpoch`: `string`, `locator`: `AttachmentLocator`, `format`: `SourceFileArtifact`[`"format"`]) => `Promise`<`ResultRef`<`SourceFileArtifact`, `"artifact"`>>

decodeSource

▸ decodeSource<Name>(name, value): Contracts[Name]

Type parameters

Name	Type
`Name`	extends keyof `Contracts`

Parameters

Name	Type
`name`	`Name`
`value`	`unknown`

Returns

Contracts[Name]

observeSource

▸ observeSource(source, options?): Promise<string | null> One authorized and fenced native source observation. Provider metadata is optional so a component’s clock deadline never waits for provider I/O.

Parameters

Name	Type
`source`	`string`
`options`	`Object`
`options.providers?`	`boolean`
`options.shared?`	`boolean`

Returns

Promise<string | null>

sourceObservationFunctions

▸ sourceObservationFunctions(collection): Object Code-owned source discovery and sampling callbacks for an installed product. Every source is read under its actual caller’s row authority. Installing these functions confers no service read or disclosure permission.

Parameters

Name	Type
`collection`	`string`

Returns

Object

Name	Type
`sources`	`RegisteredQuery`<`"internal"`, {}, `Promise`<{ `collection`: `string` ; `items`: { `source`: `string` ; `generation`: `bigint` ; `contract_revision`: `string` }[] ; `is_complete`: `boolean` }>>
`sample`	`RegisteredAction`<`"internal"`, { `source`: `string` ; `providers`: `boolean` ; `shared`: `boolean` }, `Promise`<`null` \| `string`>>

connectionTaskEffect

▸ connectionTaskEffect(request): Promise<ConnectionTaskObservation | null>

Parameters

Name	Type
`request`	`ConnectionTaskRequest`

Returns

Promise<ConnectionTaskObservation | null>

sourceReadIssue

▸ sourceReadIssue(error): ReadUnavailable | undefined A native query refusal. Error text and authorization failures are never interpreted as source availability.

Parameters

Name	Type
`error`	`unknown`

Returns

ReadUnavailable | undefined

readResultValidator

▸ readResultValidator<T>(value): VUnion<Expand<{ [Property in “value”]?: Exclude<Infer<Object[Property]>, undefined> } & { [Property in “kind” | “value”]: Infer<Object[Property]> }> | { kind: "missingEvidence" ; code: "ReadServingVersionUnavailable" | "SourceCoherenceUnavailable" | "SourcePopulationCapabilityUnavailable" | "SourcePopulationUnavailable" | "SourceCompleteVersionUnavailable" | "SourceContinuityUnavailable" | "SourceObservationCoverageRequired" | "SourceObservationUnavailable" | "SourceObservationStale" | "SourceObservationBeforeBarrier" | "FreshnessUnavailable" | "FreshnessExpired" } | { kind: "unsupported" ; code: "SourceCoherenceUnsupported" | "SourcePopulationUnsupported" | "SourceCompleteVersionNotDataset" | "SourceContinuityUnsupported" | "SourceRequirementUnsupported" | "SourceEvidenceClassUnsupported" }, [VObject<Expand<{ [Property in “value”]?: Exclude<Infer<Object[Property]>, undefined> } & { [Property in “kind” | “value”]: Infer<Object[Property]> }>, { kind: VLiteral<"ready", "required"> ; value: T }, "required", "kind" | "value" | `value.

\{T["fieldPaths"]}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"missingEvidence"`` ; `code`: ``"ReadServingVersionUnavailable"`` \| ``"SourceCoherenceUnavailable"`` \| ``"SourcePopulationCapabilityUnavailable"`` \| ``"SourcePopulationUnavailable"`` \| ``"SourceCompleteVersionUnavailable"`` \| ``"SourceContinuityUnavailable"`` \| ``"SourceObservationCoverageRequired"`` \| ``"SourceObservationUnavailable"`` \| ``"SourceObservationStale"`` \| ``"SourceObservationBeforeBarrier"`` \| ``"FreshnessUnavailable"`` \| ``"FreshnessExpired"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"missingEvidence"``, ``"required"``\> ; `code`: [`VUnion`](/api/classes/values.VUnion)\<``"ReadServingVersionUnavailable"`` \| ``"SourceCoherenceUnavailable"`` \| ``"SourcePopulationCapabilityUnavailable"`` \| ``"SourcePopulationUnavailable"`` \| ``"SourceCompleteVersionUnavailable"`` \| ``"SourceContinuityUnavailable"`` \| ``"SourceObservationCoverageRequired"`` \| ``"SourceObservationUnavailable"`` \| ``"SourceObservationStale"`` \| ``"SourceObservationBeforeBarrier"`` \| ``"FreshnessUnavailable"`` \| ``"FreshnessExpired"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"ReadServingVersionUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCoherenceUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourcePopulationCapabilityUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourcePopulationUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCompleteVersionUnavailable"``, ``"required"``\>], ``"required"``, `never`\> = readCodeValidators.SourceMissingEvidenceCode \}, ``"required"``, ``"kind"`` \| ``"code"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"unsupported"`` ; `code`: ``"SourceCoherenceUnsupported"`` \| ``"SourcePopulationUnsupported"`` \| ``"SourceCompleteVersionNotDataset"`` \| ``"SourceContinuityUnsupported"`` \| ``"SourceRequirementUnsupported"`` \| ``"SourceEvidenceClassUnsupported"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"unsupported"``, ``"required"``\> ; `code`: [`VUnion`](/api/classes/values.VUnion)\<``"SourceCoherenceUnsupported"`` \| ``"SourcePopulationUnsupported"`` \| ``"SourceCompleteVersionNotDataset"`` \| ``"SourceContinuityUnsupported"`` \| ``"SourceRequirementUnsupported"`` \| ``"SourceEvidenceClassUnsupported"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCoherenceUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourcePopulationUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCompleteVersionNotDataset"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceContinuityUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceRequirementUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceEvidenceClassUnsupported"``, ``"required"``\>], ``"required"``, `never`\> = readCodeValidators.SourceUnsupportedCode \}, ``"required"``, ``"kind"`` \| ``"code"``\>], ``"required"``, ``"kind"`` \| ``"value"`` \| ``"code"`` \| \`value.

{T[“fieldPaths”]}`> Validate a function’s ReadResult return, as paginationResultValidator validates a page.

returns: readResultValidator(v.array(v.object({ subject: v.string() }))),

Type parameters

Name	Type
`T`	extends `Validator`<`any`, `"required"`, `any`>

Parameters

Name	Type
`value`	`T`

Returns

VUnion<Expand<{ [Property in “value”]?: Exclude<Infer<Object[Property]>, undefined> } & { [Property in “kind” | “value”]: Infer<Object[Property]> }> | { kind: "missingEvidence" ; code: "ReadServingVersionUnavailable" | "SourceCoherenceUnavailable" | "SourcePopulationCapabilityUnavailable" | "SourcePopulationUnavailable" | "SourceCompleteVersionUnavailable" | "SourceContinuityUnavailable" | "SourceObservationCoverageRequired" | "SourceObservationUnavailable" | "SourceObservationStale" | "SourceObservationBeforeBarrier" | "FreshnessUnavailable" | "FreshnessExpired" } | { kind: "unsupported" ; code: "SourceCoherenceUnsupported" | "SourcePopulationUnsupported" | "SourceCompleteVersionNotDataset" | "SourceContinuityUnsupported" | "SourceRequirementUnsupported" | "SourceEvidenceClassUnsupported" }, [VObject<Expand<{ [Property in “value”]?: Exclude<Infer<Object[Property]>, undefined> } & { [Property in “kind” | “value”]: Infer<Object[Property]> }>, { kind: VLiteral<"ready", "required"> ; value: T }, "required", "kind" | "value" | `value.

\{T["fieldPaths"]}\`\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"missingEvidence"`` ; `code`: ``"ReadServingVersionUnavailable"`` \| ``"SourceCoherenceUnavailable"`` \| ``"SourcePopulationCapabilityUnavailable"`` \| ``"SourcePopulationUnavailable"`` \| ``"SourceCompleteVersionUnavailable"`` \| ``"SourceContinuityUnavailable"`` \| ``"SourceObservationCoverageRequired"`` \| ``"SourceObservationUnavailable"`` \| ``"SourceObservationStale"`` \| ``"SourceObservationBeforeBarrier"`` \| ``"FreshnessUnavailable"`` \| ``"FreshnessExpired"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"missingEvidence"``, ``"required"``\> ; `code`: [`VUnion`](/api/classes/values.VUnion)\<``"ReadServingVersionUnavailable"`` \| ``"SourceCoherenceUnavailable"`` \| ``"SourcePopulationCapabilityUnavailable"`` \| ``"SourcePopulationUnavailable"`` \| ``"SourceCompleteVersionUnavailable"`` \| ``"SourceContinuityUnavailable"`` \| ``"SourceObservationCoverageRequired"`` \| ``"SourceObservationUnavailable"`` \| ``"SourceObservationStale"`` \| ``"SourceObservationBeforeBarrier"`` \| ``"FreshnessUnavailable"`` \| ``"FreshnessExpired"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"ReadServingVersionUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCoherenceUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourcePopulationCapabilityUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourcePopulationUnavailable"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCompleteVersionUnavailable"``, ``"required"``\>], ``"required"``, `never`\> = readCodeValidators.SourceMissingEvidenceCode \}, ``"required"``, ``"kind"`` \| ``"code"``\>, [`VObject`](/api/classes/values.VObject)\<\{ `kind`: ``"unsupported"`` ; `code`: ``"SourceCoherenceUnsupported"`` \| ``"SourcePopulationUnsupported"`` \| ``"SourceCompleteVersionNotDataset"`` \| ``"SourceContinuityUnsupported"`` \| ``"SourceRequirementUnsupported"`` \| ``"SourceEvidenceClassUnsupported"`` \}, \{ `kind`: [`VLiteral`](/api/classes/values.VLiteral)\<``"unsupported"``, ``"required"``\> ; `code`: [`VUnion`](/api/classes/values.VUnion)\<``"SourceCoherenceUnsupported"`` \| ``"SourcePopulationUnsupported"`` \| ``"SourceCompleteVersionNotDataset"`` \| ``"SourceContinuityUnsupported"`` \| ``"SourceRequirementUnsupported"`` \| ``"SourceEvidenceClassUnsupported"``, [[`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCoherenceUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourcePopulationUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceCompleteVersionNotDataset"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceContinuityUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceRequirementUnsupported"``, ``"required"``\>, [`VLiteral`](/api/classes/values.VLiteral)\<``"SourceEvidenceClassUnsupported"``, ``"required"``\>], ``"required"``, `never`\> = readCodeValidators.SourceUnsupportedCode \}, ``"required"``, ``"kind"`` \| ``"code"``\>], ``"required"``, ``"kind"`` \| ``"value"`` \| ``"code"`` \| \`value.

{T[“fieldPaths”]}`>

sourceRequestIssueMessage

▸ sourceRequestIssueMessage(issue): string Presentation for one retained refresh’s diagnosis. Controls still recheck current authority and availability in the mutation.

Parameters

Name	Type
`issue`	`SourceRequestIssue`

Returns

string

acquireSourceSnapshot

▸ acquireSourceSnapshot(scope, key, reader): Promise<string> The native lease owns bounded history. A changed component definition expires enumeration rather than interpreting the cut with new code.

Parameters

Name	Type
`scope`	`string`
`key`	`string`
`reader`	`string`

Returns

Promise<string>

selectSourceSnapshot

▸ selectSourceSnapshot(scope, cut): Promise<string | null>

Parameters

Name	Type
`scope`	`string`
`cut`	`string`

Returns

Promise<string | null>

sourceSnapshotStatus

▸ sourceSnapshotStatus(scope, cut): Promise<{ expiresAt: number } | null> The original native deadline, including recovery of an existing request key. Inspection never renews a hold or selects a historical read basis.

Parameters

Name	Type
`scope`	`string`
`cut`	`string`

Returns

Promise<{ expiresAt: number } | null>

releaseSourceSnapshot

▸ releaseSourceSnapshot(scope, cut): Promise<void>

Parameters

Name	Type
`scope`	`string`
`cut`	`string`

Returns

Promise<void>

acceptReaderAuthority

▸ acceptReaderAuthority(options): Promise<ReaderAuthority> Accept the authenticated caller’s own authority for one installed snapshot reader query of this installation, with exactly inputs, until expiresAtMs and while the record this mutation names exists. Call it from the recipient’s own mutation; the recipient is the caller. Workers, services, administrators and previews cannot accept. Deleting record revokes it, and every page rechecks the recipient’s current authentication, delegation and source policy. It is never a login and authorizes no mutation.

Parameters

Name	Type
`options`	`Object`
`options.reader`	`string`
`options.record`	`string`
`options.inputs`	`Value`
`options.expiresAtMs`	`number`

Returns

Promise<ReaderAuthority>

acceptSourceSnapshotWork

▸ acceptSourceSnapshotWork(options): Promise<ReaderAuthority> Explicit finite consent for snapshot publication work. Unlike the read-only recipient authority, this permits only captured protected files, the exact receiving mutations, one format and keys under the accepted prefix. Native admission requires the actual live person or service and fences its record, code, source policies, cut and deadline on every page and consumption.

Parameters

Name	Type
`options`	`Object`
`options.reader`	`string`
`options.record`	`string`
`options.inputs`	`Value`
`options.expiresAtMs`	`number`
`options.cut`	`string`
`options.custody`	`Object`
`options.custody.receivers`	readonly `string`[]
`options.custody.format`	`string`
`options.custody.keyPrefix`	`string`
`options.custody.grantExpiresAtMs`	`number`

Returns

Promise<ReaderAuthority>

readRecipientPage

▸ readRecipientPage(authority, cut, cursor): Promise<{ kind: "observation" ; token: string } | { kind: "expired" }> In an action: run one page of the accepted reader under its recipient at the cut’s leased snapshot. The reader receives { inputs, cut, cursor } with the accepted inputs, and must return a sealed snapshotLeases observation of that cut’s lease, or null once selectSourceSnapshot reports the snapshot gone. Only that seal returns; consume it in this installation’s mutation. Explicit snapshot work consent additionally returns its native exact-file custody permit; ordinary reader authority grants none. A guest error inside the reader is refused without its message.

Parameters

Name	Type
`authority`	`string`
`cut`	`string`
`cursor`	`string` \| `null`

Returns

Promise<{ kind: "observation" ; token: string } | { kind: "expired" }>

unwrapResultResponse

▸ unwrapResultResponse<Result>(response): Result Return the complete value or throw a refusal with its stable code.

Type parameters

Name
`Result`

Parameters

Name	Type
`response`	`ResultResponse`<`Result`>

Returns

Result

defineVirtualTable

▸ defineVirtualTable<Row>(definition): VirtualTableDefinition<Row>

Type parameters

Name	Type
`Row`	extends `Record`<`string`, `any`>

Parameters

Name	Type
`definition`	`Object`
`definition.source`	`VirtualDataset`<`Row`>

Returns

VirtualTableDefinition<Row> ▸ defineVirtualTable<Source>(definition): VirtualTableDefinition<ObjectType<Source["schema"]>>

Type parameters

Name	Type
`Source`	extends `CapturedVirtualTable`<`PropertyValidators`>

Parameters

Name	Type
`definition`	`Object`
`definition.source`	`Source`
`definition.executor`	`Source` extends `CapturedVirtualTable`<`any`, infer Engine> ? `RelationalExecutor`<`Engine` \| `undefined`> : `never`

Returns

VirtualTableDefinition<ObjectType<Source["schema"]>> ▸ defineVirtualTable<Fields>(definition): VirtualTableDefinition<ObjectType<Fields>>

Type parameters

Name	Type
`Fields`	extends `PropertyValidators`

Parameters

Name	Type
`definition`	`Object`
`definition.source`	`SourceHandle`<`Fields`>

Returns

VirtualTableDefinition<ObjectType<Fields>> ▸ defineVirtualTable<Fields>(definition): VirtualTableDefinition<ObjectType<Fields>>

Type parameters

Name	Type
`Fields`	extends `PropertyValidators`

Parameters

Name	Type
`definition`	`VirtualTableDeclaration`<`Fields`>

Returns

VirtualTableDefinition<ObjectType<Fields>>

​Classes

​Interfaces

​References

​ReportQualificationInspection

​ReportQualificationUpdate

​SourceCapacity

​SourceControlAction

​SourceControlOutcome

​SourceControlReceipt

​SourceControlRequest

​SourceInspection

​SourceRefreshRequest

​SourceRequestPhase

​SourceRequestStatus

​Type Aliases

​IntegrationAddress

​Type declaration

​DeclaredBody

​Type parameters

​HttpResponseBody

​Type parameters

​HttpOutcome

​Type parameters

​Type declaration

​SyncEvery

​CommandGoverningResult

​CommandDeliveryContract

​Type parameters

​CommandGoverningInput

​Type declaration

​RelationalExecutor

​Type parameters

​RetainedAccessBinding

​Type parameters

​AccessWriteProgram

​Type declaration

​HttpProvider

​ConnectionRequest

​Type declaration

​HttpEffect

​HttpConnectionRef

​ActionEffects

​HttpEffectRequest

​HttpEffectResponse

​EffectContext

​Type parameters

​Type declaration

​ConnectionCheckSource

​Type declaration

​NativeCheckControls

​Type declaration

​ConnectionCheckHistoryEntry

​Type declaration

​ApplicationConnectionChecks

​Type declaration

​Context

​ApplicationExternalResources

​Type declaration

​BrowserAddress

​Type declaration

​BrowserContract

​Type parameters

​Type declaration

​BrowserElement

​Type declaration

​BrowserPage

​Type parameters

​Type declaration

​BrowserImplementation

​Type parameters

​BrowserProtocol

​BrowserResourceReference

​Type parameters

​BrowserSessionRequest

​Type declaration

​BrowserSession

​Type declaration

​BrowserSessionStatus

​Type declaration

​Reference

Classes

Interfaces

References

ReportQualificationInspection

ReportQualificationUpdate

SourceCapacity

SourceControlAction

SourceControlOutcome

SourceControlReceipt

SourceControlRequest

SourceInspection

SourceRefreshRequest

SourceRequestPhase

SourceRequestStatus

Type Aliases

IntegrationAddress

Type declaration

DeclaredBody

Type parameters

HttpResponseBody

Type parameters

HttpOutcome

Type parameters

Type declaration

SyncEvery

CommandGoverningResult

CommandDeliveryContract

Type parameters

CommandGoverningInput

Type declaration

RelationalExecutor

Type parameters

RetainedAccessBinding

Type parameters

AccessWriteProgram

Type declaration

HttpProvider

ConnectionRequest

Type declaration

HttpEffect

HttpConnectionRef

ActionEffects

HttpEffectRequest

HttpEffectResponse

EffectContext

Type parameters

Type declaration

ConnectionCheckSource

Type declaration

NativeCheckControls

Type declaration

ConnectionCheckHistoryEntry

Type declaration

ApplicationConnectionChecks

Type declaration

Context

ApplicationExternalResources

Type declaration

BrowserAddress

Type declaration

BrowserContract

Type parameters

Type declaration

BrowserElement

Type declaration

BrowserPage

Type parameters

Type declaration

BrowserImplementation

Type parameters

BrowserProtocol

BrowserResourceReference

Type parameters

BrowserSessionRequest

Type declaration

BrowserSession

Type declaration

BrowserSessionStatus

Type declaration

Reference