Module: server - Bijection

Utilities for implementing server-side Bijection query and mutation functions.

Usage

Code Generation

This module is typically used alongside generated server code. To generate the server code, run bijection dev in your Bijection project. This will create a bijection/_generated/server.js file with the following functions, typed for your schema:

If you aren’t using TypeScript and code generation, you can use these untyped functions instead:

Example

Bijection functions are defined by using either the query or mutation wrappers. Queries receive a db that implements the GenericDatabaseReader interface.

import { query } from "./_generated/server";

export default query({
  handler: async ({ db }, { arg1, arg2 }) => {
    // Your (read-only) code here!
  },
});

If your function needs to write to the database, such as inserting, updating, or deleting documents, use mutation instead which provides a db that implements the GenericDatabaseWriter interface.

import { mutation } from "./_generated/server";

export default mutation({
  handler: async ({ db }, { arg1, arg2 }) => {
    // Your mutation code here!
  },
});

Classes

Interfaces

References

UserIdentityAttributes

Re-exports UserIdentityAttributes

Type Aliases

FunctionType

Ƭ FunctionType: "query" | "mutation" | "action" The type of a Bijection function.

FunctionReference

Ƭ FunctionReference<Type, Visibility, Args, ReturnType, ComponentPath>: Object A reference to a registered Bijection function. You can create a FunctionReference using the generated api utility:

import { api } from "../bijection/_generated/api";

const reference = api.myModule.myFunction;

If you aren’t using code generation, you can create references using anyApi:

import { anyApi } from "bijection/server";

const reference = anyApi.myModule.myFunction;

Function references can be used to invoke functions from the client. For example, in React you can pass references to the useQuery hook:

const result = useQuery(api.myModule.myFunction);

If you want to accept a FunctionReference as a callback argument, prefer typing the callback parameter as FunctionReference_future.

Type parameters

Name	Type	Description
`Type`	extends `FunctionType`	The type of the function (“query”, “mutation”, or “action”).
`Visibility`	extends `FunctionVisibility` = `"public"`	The visibility of the function (“public” or “internal”).
`Args`	extends `DefaultFunctionArgs` = `any`	The arguments to this function. This is an object mapping argument names to their types.
`ReturnType`	`any`	The return type of this function.
`ComponentPath`	`string` \| `undefined`	-

Type declaration

Name	Type	Description
`_type`	`Type`	-
`_visibility`	`Visibility`	-
`_args`	`Args`	To read the arguments for a `FunctionReference`, prefer FunctionArgs. This slot will be removed in a future version. `Deprecated`
`_returnType`	`ReturnType`	To read the return type of a `FunctionReference`, prefer FunctionReturnType. This slot will be removed in a future version. `Deprecated`
`_componentPath`	`ComponentPath`	-
`_fn?`	(`args`: `Args`, `keys`: `FunctionReferenceArgKeys`<`Args`>) => `ReturnType`	To read the arguments or return type of a `FunctionReference`, prefer FunctionArgs and FunctionReturnType.

FunctionReference_future

Ƭ FunctionReference_future<Type, Visibility, Args, ReturnType, ComponentPath>: Object A reference to a Bijection function whose arguments are checked closer to the way Bijection checks them at runtime. Use this instead of FunctionReference when you accept someone else’s Bijection function as a callback and know which arguments you will pass it. A plain FunctionReference gets a couple things backwards: it accepts a function requiring arguments you never pass, and rejects a function accepting broader values than you pass. An ordinary TypeScript function type doesn’t map perfectly either: it treats a surplus argument as harmless, where a Bijection validator rejects it. This type melds regular TypeScript function reference behavior with top level checking of arguments to prevent surplus arguments from hitting runtime validation errors. The caveat: a surplus key inside a nested object, an array element, or one arm of a union passes the type check and fails the validator at runtime.

import { FunctionReference_future } from "bijection/server";

declare function onComplete(
  fn: FunctionReference_future<
    "mutation",
    "internal",
    { taskId: string; force: boolean },
    null
  >,
): void;

// Takes exactly `{ taskId: string; force: boolean }`.
onComplete(internal.tasks.finish);
// Takes `{ taskId: string | number; force?: boolean }`: calling it is safe.
onComplete(internal.tasks.finishLoosely);
// Requires a `reason` argument that `onComplete` never passes.
onComplete(internal.tasks.finishWithReason);
//          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ rejected
// Takes only `{ taskId: string }`: its validator would reject `force`.
onComplete(internal.tasks.finishById);
//          ~~~~~~~~~~~~~~~~~~~~~~~~ rejected

A value of this type is usable with ctx.runMutation, ctx.scheduler.runAfter, createFunctionHandle, and everything else in this package that takes a reference, all of which accept either kind. It is not assignable to a plain FunctionReference. Code that wants to accept both kinds should take FunctionReference<...> | FunctionReference_future<...> and read arguments and return types through FunctionArgs and FunctionReturnType. Argument checking here relies on strictFunctionTypes (implied by strict) and is skipped for projects that disable it. Everything else about the reference is compared exactly as FunctionReference compares it.

Type parameters

Name	Type	Description
`Type`	extends `FunctionType`	The type of the function (“query”, “mutation”, or “action”).
`Visibility`	extends `FunctionVisibility` = `"public"`	The visibility of the function (“public” or “internal”).
`Args`	extends `DefaultFunctionArgs` = `any`	The arguments the consumer of the reference will pass.
`ReturnType`	`any`	The return type of this function.
`ComponentPath`	`string` \| `undefined`	-

Type declaration

Name	Type
`_type`	`Type`
`_visibility`	`Visibility`
`_componentPath`	`ComponentPath`
`_fn?`	(`args`: `Args`, `keys`: `FunctionReference_futureArgKeys`<`Args`>) => `ReturnType`

ApiFromModules

Ƭ ApiFromModules<AllModules>: FilterApi<ApiFromModulesAllowEmptyNodes<AllModules>, FunctionReference<any, any, any, any> | OperationReference<any, any, any>> Given the types of all modules in the bijection/ directory, construct the type of api. api is a utility for constructing FunctionReferences.

Type parameters

Name	Type	Description
`AllModules`	extends `Record`<`string`, `object`>	A type mapping module paths (like `"dir/myModule"`) to the types of the modules.

FilterApi

Ƭ FilterApi<API, Predicate>: Expand<{ [mod in keyof API as FilterKeysInApi<mod, API[mod], Predicate>]: API[mod] extends Predicate ? API[mod] : FilterApi<API[mod], Predicate> }> Filter a Bijection deployment api object for functions which meet criteria, for example all public queries.

Type parameters

Name
`API`
`Predicate`

AnyApi

Ƭ AnyApi: Record<string, Record<string, AnyModuleDirOrFunc>> The type that Bijection api objects extend. If you were writing an api from scratch it should extend this type.

PartialApi

Ƭ PartialApi<API>: { [mod in keyof API]?: API[mod] extends FunctionReference<any, any, any, any> | OperationReference<any, any, any> ? API[mod] : PartialApi<API[mod]> } Recursive partial API, useful for defining a subset of an API when mocking or building custom api objects.

Type parameters

Name
`API`

FunctionArgs

Ƭ FunctionArgs<FuncRef>: ExtractSignature<FuncRef>["args"] Given a FunctionReference or FunctionReference_future, get the arguments of the function. This is represented as an object mapping argument names to values.

Type parameters

Name	Type
`FuncRef`	extends `FunctionReference`<`any`, `any`> \| `FunctionReference_future`<`any`, `any`> \| `OperationReference`<`any`, `any`, `any`>

OptionalRestArgs

Ƭ OptionalRestArgs<FuncRef>: FunctionArgs<FuncRef> extends EmptyObject ? [args?: EmptyObject] : [args: FunctionArgs<FuncRef>] A tuple type of the (maybe optional) arguments to FuncRef. This type is used to make methods involving arguments type safe while allowing skipping the arguments for functions that don’t require arguments.

Type parameters

Name	Type
`FuncRef`	extends `FunctionReference`<`any`, `any`> \| `FunctionReference_future`<`any`, `any`> \| `OperationReference`<`any`, `any`, `any`>

ArgsAndOptions

Ƭ ArgsAndOptions<FuncRef, Options>: FunctionArgs<FuncRef> extends EmptyObject ? [args?: EmptyObject, options?: Options] : [args: FunctionArgs<FuncRef>, options?: Options] A tuple type of the (maybe optional) arguments to FuncRef, followed by an options object of type Options. This type is used to make methods like useQuery type-safe while allowing

Skipping arguments for functions that don’t require arguments.
Skipping the options object.

Type parameters

Name	Type
`FuncRef`	extends `FunctionReference`<`any`, `any`> \| `FunctionReference_future`<`any`, `any`>
`Options`	`Options`

FunctionReturnType

Ƭ FunctionReturnType<FuncRef>: ExtractSignature<FuncRef>["returnType"] Given a FunctionReference or FunctionReference_future, get the return type of the function.

Type parameters

Name	Type
`FuncRef`	extends `FunctionReference`<`any`, `any`> \| `FunctionReference_future`<`any`, `any`> \| `OperationReference`<`any`, `any`, `any`>

ValidatorTypeToReturnType

Ƭ ValidatorTypeToReturnType<T>: Promise<NullToUndefinedOrNull<T>> | NullToUndefinedOrNull<T>

Type parameters

Name
`T`

ApplicationSourceControl

Ƭ ApplicationSourceControl: (ctx: GenericMutationCtx<GenericDataModel>, request: { action: "sync" | "check" ; collection: string ; source: string }) => Promise<boolean>

Type declaration

▸ (ctx, request): Promise<boolean> The program’s decision whether this caller may ask for a sync of, or a connection check on, one source of an exposed synced collection (applicationQueries({ sourceControl })). Whoever it allows spends provider budget; the engine’s coalescing and the connection’s budget bound that. It runs after authorize and the collection check, with the caller’s own context, and only true allows the request.

Parameters

Name	Type
`ctx`	`GenericMutationCtx`<`GenericDataModel`>
`request`	`Object`
`request.action`	`"sync"` \| `"check"`
`request.collection`	`string`
`request.source`	`string`

Returns

Promise<boolean>

CollectionNotificationKind

Ƭ CollectionNotificationKind: Object A category whose events are rows of an exposed collection: the event names the object it is about in objectProperty and carries its message in messageProperty. With tab, the notice opens that object view tab with the event itself as its detail.

Type declaration

Name	Type
`label`	`string`
`eventCollection`	`string`
`objectCollection`	`string`
`objectProperty`	`string`
`messageProperty`	`string`
`tab?`	`string`

AppNoticeContent

Ƭ AppNoticeContent: Object What a resolved category’s event is, as the reader may see it now. The message is cut to APP_NOTICE_MESSAGE_MAX characters. An object subject names an exposed collection’s object, which is titled through the reader’s own read of it; a page subject names a workspace page by its kebab-case id, the route it opens and its title (at most 200 characters are shown).

Type declaration

Name	Type
`message`	`string`
`subject`	{ `kind`: `"object"` ; `collection`: `string` ; `id`: `string` ; `tab?`: `string` ; `detail?`: `string` } \| { `kind`: `"page"` ; `page`: `string` ; `route?`: `AppNoticeRoute` ; `title`: `string` }

ResolvedNotificationKind

Ƭ ResolvedNotificationKind: Object A category resolved by product code. resolve runs inside the reader’s own notification query and updates, with the READER’s context and current authority, and answers the notice or null to omit it. It may make at most one protected read for an object subject (the object is read once more to title it) and two for a page subject: a notification is budgeted READ_SUBJECTS_PER_NOTIFICATION read subjects, its delivery row included, and a query beyond the engine’s bound fails whole. An answer that does not have the shape above is omitted like null.

Type declaration

Name	Type
`label`	`string`
`resolve`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `event`: `string`) => `Promise`<`AppNoticeContent` \| `null`>

ApplicationNotificationKind

Ƭ ApplicationNotificationKind: CollectionNotificationKind | ResolvedNotificationKind

ApplicationNotifications

Ƭ ApplicationNotifications: Object Customer-owned delivery state referencing authoritative business events. table is a private table with by_recipient_read and by_recipient_archive indexes whose rows are applicationNotificationRows. kinds declares at most sixteen categories, each keyed by a kebab-case identifier. The in-app recipient is the caller’s own person (applicationQueries({ people })).

Type declaration

Name	Type
`table`	`string`
`kinds`	`Record`<`string`, `ApplicationNotificationKind`>
`recipient?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>) => `Promise`<`string` \| `null`>

ApplicationPeople

Ƭ ApplicationPeople: Object Who the application’s people are: the one identity every recipient, grantee, author and mention names. collection is an exposed collection whose objects are the people. It declares search, so a person can be found by name, it is not a connection type, and its title property is a person’s name: names are read through it under the reader’s rules, never stored beside an id. self answers the signed-in caller’s own person: the id of their object in collection, or null when the caller is not one of its people. It runs after authorize, with the caller’s context, so its reads are the caller’s.

Type declaration

Name	Type
`collection`	`string`
`self`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>) => `Promise`<`string` \| `null`>

AppPlace

Ƭ AppPlace: Object One place a location search found: WGS84 [longitude, latitude], how precise the match is, and the provider’s attribution text.

Type declaration

Name	Type
`label`	`string`
`position`	[`number`, `number`]
`precision`	`"address"` \| `"street"` \| `"locality"` \| `"region"`
`attribution`	`string`

AppPlaceSearch

Ƭ AppPlaceSearch: { status: "pending" } | { status: "answered" ; places: AppPlace[] } | { status: "failed" | "unknown" ; message: string } A durable location search as its reader answers it: still pending, answered with at most APP_PLACES places, or failed / of unknown outcome with the provider’s message.

ApplicationPlaces

Ƭ ApplicationPlaces: Object A program’s location search (applicationQueries({ places })). A search is durable intent: request records it under the caller in the calling mutation and the program’s own scheduled work asks its provider, so the browser never holds a provider key; read answers the recorded request reactively. Both run in the application’s functions with the caller’s authority, after the application’s authorize.

Type declaration

Name	Type
`request`	(`ctx`: `GenericMutationCtx`<`GenericDataModel`>, `text`: `string`) => `Promise`<`string`>
`read`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `id`: `string`) => `Promise`<`null` \| `AppPlaceSearch`>

ApplicationMapValues

Ƭ ApplicationMapValues: Record<string, { collection: string ; label: string ; values: (ctx: GenericQueryCtx<GenericDataModel>, ids: string[]) => Promise<Record<string, null | string | number>> }> Values a program computes for map styling (Foundry function-backed styling), by name: each belongs to one exposed collection and answers for the ids it is given. The mapValues query reads every object through the ordinary authorized read first and passes only readable ids.

AppSpatialBound

Ƭ AppSpatialBound: Object What an index may spend reading. subjects is the read-access budget of a collection read under per-row access checks, null for a collection read without them. The engine records one subject per distinct range demand (a range’s equalities) and rowCost per distinct row visited, matching or not.

Type declaration

Name	Type
`subjects`	`number` \| `null`
`rowCost`	`number`

AppSpatialIndex

Ƭ AppSpatialIndex: Object A program’s spatial index over one declared geometry property: the reads that answer the property’s spatial clauses. Each runs with ordinary reads of the collection in the calling query, under the caller’s authority.

kind: points for a point property (regions of every kind by intersects and disjoint, nearest objects, cells), shapes for any other (box and polygon regions by every mode).
table: the collection the index reads, which is the collection it answers for: its reads are the collection’s own, under its read rule.
index: the index of table its range reads use; the engine’s row cost for it bounds them, and an index the engine reports unbounded refuses every clause.
cells: the grid systems cellOf answers (none for shapes).
select: the objects of the collection whose value relates to region by mode, at most limit, in any order, as the index’s reads returned them. isComplete: false when more may match or the reads could not cover the region within subjects; the application then refuses the scope rather than answering from part of it. An object without a value matches no mode.
nearest: the k located objects nearest center within maxMetres, nearest first (ties by id), with their distances in metres, or fewer when fewer exist; isComplete: false when the ranking could not be proven within subjects. A shapes index refuses it.
cellOf: the cell of grouping holding one object’s point value, or null when it has none (a shapes index answers null).

Type declaration

Name	Type
`kind`	`"points"` \| `"shapes"`
`table`	`string`
`index`	`string`
`cells`	`AppCellSystem`[]
`select`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `query`: { `region`: `AppRegion` ; `mode`: `AppSpatialMode` }, `bound`: `AppSpatialBound` & { `limit`: `number` }) => `Promise`<{ `objects`: `GenericDocument`[] ; `isComplete`: `boolean` }>
`nearest`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `query`: { `center`: [`number`, `number`] ; `k`: `number` ; `maxMetres`: `number` }, `bound`: `AppSpatialBound`) => `Promise`<{ `ranked`: { `object`: `GenericDocument` ; `distanceMetres`: `number` }[] ; `isComplete`: `boolean` }>
`cellOf`	(`value`: `AppGeometry`, `grouping`: `AppCellGrouping`) => `null` \| `string`

AppSpatialIndexes

Ƭ AppSpatialIndexes: Record<string, Record<string, AppSpatialIndex>> Spatial indexes by collection and declared geometry property.

AuditLogBody

Ƭ AuditLogBody: Object

Index signature

▪ [key: string]: AuditLogValue

AuditLogValue

Ƭ AuditLogValue: null | undefined | boolean | number | string | LogVar | AuditLogValue[] | { [key: string]: AuditLogValue; }

AuthConfig

Ƭ AuthConfig: Object The value exported by your Bijection project in auth.config.ts.

import { AuthConfig } from "bijection/server";

export default {
  providers: [
    {
      domain: "https://your.issuer.url.com",
      applicationID: "your-application-id",
    },
  ],
} satisfies AuthConfig;

Type declaration

Name	Type
`providers`	`AuthProvider`[]

AuthProvider

Ƭ AuthProvider: { applicationID: string ; domain: string } | { type: "customJwt" ; applicationID?: string ; issuer: string ; jwks: string ; algorithm: "RS256" | "ES256" } An authentication provider allowed to issue JWTs for your app. See: https://docs.bijection.com/auth/advanced/custom-auth and https://docs.bijection.com/auth/advanced/custom-jwt

FunctionHandle

Ƭ FunctionHandle<Type, Args, ReturnType>: string & FunctionReference<Type, "internal", Args, ReturnType> A serializable reference to a Bijection function. Passing a this reference to another component allows that component to call this function during the current function execution or at any later time. Function handles are used like api.folder.function FunctionReferences, e.g. ctx.scheduler.runAfter(0, functionReference, args). A function reference is stable across code pushes but it’s possible the Bijection function it refers to might no longer exist. This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.

Type parameters

Name	Type
`Type`	extends `FunctionType`
`Args`	extends `DefaultFunctionArgs` = `any`
`ReturnType`	`any`

ComponentDefinition

Ƭ ComponentDefinition<Exports, Env>: Object An object of this type should be the default export of a bijection.config.ts file in a component definition directory. This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.

Type parameters

Name	Type
`Exports`	extends `ComponentExports` = `any`
`Env`	extends `EnvDefinition` = {}

Type declaration

Name	Type	Description
`use`	<Definition>(`definition`: `Definition`, …`args`: `UseArgs`<`Definition`>) => `InstalledComponent`<`Definition`>	Install a component with the given definition in this component definition. Takes a component definition and an optional name. For editor tooling this method expects a ComponentDefinition but at runtime the object that is imported will be a ImportedComponentDefinition
`__exports`	`Exports`	Internal type-only property tracking exports provided. `Deprecated` This is a type-only property, don’t use it.
`env`	`EnvRefFromDefinition`<`Env`>	References to this component’s declared env vars. Pass one of these in `app.use(child, { env: { ... } })` to bind a child’s env var by reference to this component’s env var.
`__env`	`Env`	Internal type-only property tracking env definition. `Deprecated` This is a type-only property, don’t use it.

EnvDefinition

Ƭ EnvDefinition: Record<string, StringLikeValidator | VOptional<StringLikeValidator>> A definition of environment variables for the app. Maps environment variable names to string-like validators. Use v.string() for a plain string, v.literal("a") for an enum value, or v.union(v.literal("a"), v.literal("b")) for an enum. Wrap in v.optional(...) for optional vars. Example

import { defineApp } from "bijection/server";
import { v } from "bijection/values";

const app = defineApp({
  env: {
    OPENAI_API_KEY: v.string(),
    DEBUG_MODE: v.optional(v.string()),
  },
});

EnvFromDefinition

Ƭ EnvFromDefinition<E>: Expand<{ [K in keyof E as E[K] extends Validator<any, “optional”, any> ? never : K]: Infer<E[K]> } & { [K in keyof E as E[K] extends Validator<any, “optional”, any> ? K : never]?: Infer<E[K]> }> Compute the typed environment object from an EnvDefinition. Required entries get the validator’s inferred string type; optional entries are T | undefined.

Type parameters

Name	Type
`E`	extends `EnvDefinition`

EnvFromAppDefinition

Ƭ EnvFromAppDefinition<A>: A extends AppDefinition<infer E> ? EnvFromDefinition<E> : Record<string, never> Extract the typed environment from an AppDefinition.

Type parameters

Name
`A`

AppDefinition

Ƭ AppDefinition<Env>: Object An object of this type should be the default export of a bijection.config.ts file in a component-aware bijection directory. This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.

Type parameters

Name	Type
`Env`	extends `EnvDefinition` = `EnvDefinition`

Type declaration

Name	Type	Description
`use`	<Definition>(`definition`: `Definition`, …`args`: `UseArgs`<`Definition`>) => `InstalledComponent`<`Definition`>	Install a component with the given definition in this component definition. Takes a component definition and an optional name. For editor tooling this method expects a ComponentDefinition but at runtime the object that is imported will be a ImportedComponentDefinition
`env`	`EnvRefFromDefinition`<`Env`>	References to this app’s declared env vars. Pass one of these in `app.use(child, { env: { ... } })` to bind a child’s env var by reference to this app’s env var.
`__env`	`Env`	Internal type-only property tracking env definition. `Deprecated` This is a type-only property, don’t use it.

AnyChildComponents

Ƭ AnyChildComponents: Record<string, AnyComponentReference>

AnyComponents

Ƭ AnyComponents: AnyChildComponents

UploadCompletionReference

Ƭ UploadCompletionReference: FunctionReference<"mutation", "public" | "internal", { file: GenericId<"_storage"> }> A mutation that attaches a newly uploaded file: it receives the file as file beside the arguments its preparation named.

BijectionQueryBuilder

Ƭ BijectionQueryBuilder<DM, V>: BijectionFunctionBuilder<DM, V, "query">

Type parameters

Name	Type
`DM`	extends `GenericDataModel`
`V`	extends `FunctionVisibility`

BijectionMutationBuilder

Ƭ BijectionMutationBuilder<DM, V>: BijectionFunctionBuilder<DM, V, "mutation">

Type parameters

Name	Type
`DM`	extends `GenericDataModel`
`V`	extends `FunctionVisibility`

BijectionActionBuilder

Ƭ BijectionActionBuilder<DM, V>: BijectionFunctionBuilder<DM, V, "action">

Type parameters

Name	Type
`DM`	extends `GenericDataModel`
`V`	extends `FunctionVisibility`

GenericDocument

Ƭ GenericDocument: Record<string, Value> A document stored in Bijection.

GenericFieldPaths

Ƭ GenericFieldPaths: string A type describing all of the document fields in a table. These can either be field names (like “name”) or references to fields on nested objects (like “properties.name”).

GenericIndexFields

Ƭ GenericIndexFields: string[] A type describing the ordered fields in an index. These can either be field names (like “name”) or references to fields on nested objects (like “properties.name”).

GenericTableIndexes

Ƭ GenericTableIndexes: Record<string, GenericIndexFields> A type describing the indexes in a table. It’s an object mapping each index name to the fields in the index.

GenericSearchIndexConfig

Ƭ GenericSearchIndexConfig: Object A type describing the configuration of a search index.

Type declaration

Name	Type
`searchField`	`string`
`filterFields`	`string`

GenericTableSearchIndexes

Ƭ GenericTableSearchIndexes: Record<string, GenericSearchIndexConfig> A type describing all of the search indexes in a table. This is an object mapping each index name to the config for the index.

GenericVectorIndexConfig

Ƭ GenericVectorIndexConfig: Object A type describing the configuration of a vector index.

Type declaration

Name	Type
`vectorField`	`string`
`dimensions`	`number`
`filterFields`	`string`

GenericTableVectorIndexes

Ƭ GenericTableVectorIndexes: Record<string, GenericVectorIndexConfig> A type describing all of the vector indexes in a table. This is an object mapping each index name to the config for the index.

FieldTypeFromFieldPath

Ƭ FieldTypeFromFieldPath<Document, FieldPath>: FieldTypeFromFieldPathInner<Document, FieldPath> extends Value | undefined ? FieldTypeFromFieldPathInner<Document, FieldPath> : Value | undefined The type of a field in a document. Note that this supports both simple fields like “name” and nested fields like “properties.name”. If the field is not present in the document it is considered to be undefined.

Type parameters

Name	Type
`Document`	extends `GenericDocument`
`FieldPath`	extends `string`

FieldTypeFromFieldPathInner

Ƭ FieldTypeFromFieldPathInner<Document, FieldPath>: FieldPath extends `

\{infer First}.

{infer Second}` ? ValueFromUnion<Document, First, Record<never, never>> extends infer FieldValue ? FieldValue extends GenericDocument ? FieldTypeFromFieldPath<FieldValue, Second> : undefined : undefined : ValueFromUnion<Document, FieldPath, undefined> The inner type of FieldTypeFromFieldPath. It’s wrapped in a helper to coerce the type to Value | undefined since some versions of TypeScript fail to infer this type correctly.

Type parameters

Name	Type
`Document`	extends `GenericDocument`
`FieldPath`	extends `string`

GenericTableInfo

Ƭ GenericTableInfo: Object A type describing the document type and indexes in a table.

Type declaration

Name	Type
`document`	`GenericDocument`
`fieldPaths`	`GenericFieldPaths`
`indexes`	`GenericTableIndexes`
`searchIndexes`	`GenericTableSearchIndexes`
`vectorIndexes`	`GenericTableVectorIndexes`

DocumentByInfo

Ƭ DocumentByInfo<TableInfo>: TableInfo["document"] The type of a document in a table for a given GenericTableInfo.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

FieldPaths

Ƭ FieldPaths<TableInfo>: TableInfo["fieldPaths"] The field paths in a table for a given GenericTableInfo. These can either be field names (like “name”) or references to fields on nested objects (like “properties.name”).

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

Indexes

Ƭ Indexes<TableInfo>: TableInfo["indexes"] The database indexes in a table for a given GenericTableInfo. This will be an object mapping index names to the fields in the index.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

IndexNames

Ƭ IndexNames<TableInfo>: keyof Indexes<TableInfo> The names of indexes in a table for a given GenericTableInfo.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

NamedIndex

Ƭ NamedIndex<TableInfo, IndexName>: Indexes<TableInfo>[IndexName] Extract the fields of an index from a GenericTableInfo by name.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`
`IndexName`	extends `IndexNames`<`TableInfo`>

SearchIndexes

Ƭ SearchIndexes<TableInfo>: TableInfo["searchIndexes"] The search indexes in a table for a given GenericTableInfo. This will be an object mapping index names to the search index config.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

SearchIndexNames

Ƭ SearchIndexNames<TableInfo>: keyof SearchIndexes<TableInfo> The names of search indexes in a table for a given GenericTableInfo.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

NamedSearchIndex

Ƭ NamedSearchIndex<TableInfo, IndexName>: SearchIndexes<TableInfo>[IndexName] Extract the config of a search index from a GenericTableInfo by name.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`
`IndexName`	extends `SearchIndexNames`<`TableInfo`>

VectorIndexes

Ƭ VectorIndexes<TableInfo>: TableInfo["vectorIndexes"] The vector indexes in a table for a given GenericTableInfo. This will be an object mapping index names to the vector index config.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

VectorIndexNames

Ƭ VectorIndexNames<TableInfo>: keyof VectorIndexes<TableInfo> The names of vector indexes in a table for a given GenericTableInfo.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`

NamedVectorIndex

Ƭ NamedVectorIndex<TableInfo, IndexName>: VectorIndexes<TableInfo>[IndexName] Extract the config of a vector index from a GenericTableInfo by name.

Type parameters

Name	Type
`TableInfo`	extends `GenericTableInfo`
`IndexName`	extends `VectorIndexNames`<`TableInfo`>

GenericDataModel

Ƭ GenericDataModel: Record<string, GenericTableInfo> A type describing the tables in a Bijection project. This is designed to be code generated with bijection dev.

AnyDataModel

Ƭ AnyDataModel: Object A GenericDataModel that considers documents to be any and does not support indexes. This is the default before a schema is defined.

Index signature

▪ [tableName: string]: { document: any ; fieldPaths: GenericFieldPaths ; indexes: SystemIndexes ; searchIndexes: {} ; vectorIndexes: {} }

TableNamesInDataModel

Ƭ TableNamesInDataModel<DataModel>: keyof DataModel & string A type of all of the table names defined in a GenericDataModel.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

NamedTableInfo

Ƭ NamedTableInfo<DataModel, TableName>: DataModel[TableName] Extract the TableInfo for a table in a GenericDataModel by table name.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`TableName`	extends keyof `DataModel`

DocumentByName

Ƭ DocumentByName<DataModel, TableName>: DataModel[TableName]["document"] The type of a document in a GenericDataModel by table name.

Type parameters

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

WritableTableNames

Ƭ WritableTableNames<DataModel>: { [Name in TableNamesInDataModel<DataModel>]: DataModel[Name] extends Object ? never : Name }[TableNamesInDataModel<DataModel>] Tables accepting ordinary application writes according to generated ownership metadata.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

TableKey

Ƭ TableKey<DataModel, Name>: 0 extends 1 & DataModel[Name] ? GenericId<Name> : DataModel[Name] extends { key: infer Key } ? Key : GenericId<Name> Key accepted by a table-qualified read. A keyed view preserves its authoritative key domain.

Type parameters

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

ExternalCallStatus

pending: persisted, not yet delivered.
held: waiting on its ordering domain or an approval.
unknown: a dispatch’s outcome could not be established; it stays unknown until reconciled, and is never read as a failure.
delivered, refused: the destination’s settled answer.
indeterminate, delivered_unacknowledged, not_applied, duplicated: what reconciliation established when the answer itself was not proof.
superseded: replaced by a later operation.

The provider’s own name for a refusal never crosses.

ExpressionOrValue

Ƭ ExpressionOrValue<T>: Expression<T> | T An Expression or a constant Value

Type parameters

Name	Type
`T`	extends `Value` \| `undefined`

AccessFields

Ƭ AccessFields: readonly string[] | "rest" The fields a permission covers: a list, or every field no other permission of the same map lists.

AccessRowGrant

Ƭ AccessRowGrant: string | { role: string ; members: { type: string ; permission: string } } A field of a row that names users or groups and so confers a role on them: a grant stored in the row.

AccessTypeDefinition

Ƭ AccessTypeDefinition: Object One object type.

Type declaration

Name	Type	Description
`table?`	`string`	The table backing the type. Omit it for a key-only type such as an organization or a group, whose objects exist only as grant keys.
`parent?`	{ `field`: `string` ; `type`: `string` ; `index?`: `string` }	The field naming the parent object, the parent’s type, and the index (default `by_<field>`) pinning the field. A type without a parent is a child of the root. Key-only types cannot declare a parent.
`parent.field`	`string`	-
`parent.type`	`string`	-
`parent.index?`	`string`	-
`permissions?`	readonly `string`[]	Additional permission names beyond the read and write maps, `create`, `delete` and one `grant.<role>` per role of the type, which are implied.
`read?`	`Record`<`string`, `AccessFields`>	Read permissions by the fields they cover. Every field belongs to exactly one; the one covering `_id` decides whether an object is visible at all. Default: `{ read: "rest" }`.
`write?`	`Record`<`string`, `AccessFields`>	Write permissions by the fields they cover. Default: `{ edit: "rest" }`.
`restrictions?`	{ `root?`: { `type`: `string` ; `category`: `string` } ; `field?`: { `name`: `string` ; `type`: `string` } }	Restrictions: the tenant root the caller must pass, and a field listing restricting objects (markings). Inherited by descendants. Both restricting types are children of the root.
`restrictions.root?`	{ `type`: `string` ; `category`: `string` }	-
`restrictions.root.type`	`string`	-
`restrictions.root.category`	`string`	-
`restrictions.field?`	{ `name`: `string` ; `type`: `string` }	-
`restrictions.field.name`	`string`	-
`restrictions.field.type`	`string`	-
`category?`	`string` \| { `from`: `"key"` }	For a type whose objects restrict others: the category of each object, fixed or taken from the key prefix before `:`.
`rowGrants?`	`Record`<`string`, `AccessRowGrant`>	Row fields that confer a role, keyed by field name. A string names a role of this type conferred on the user keys the field holds.
`holders?`	`string`	A permission of this type whose holders may see who holds grants on an object. Without it, only holders of a `grant.*` permission may.

AccessRoleDefinition

Ƭ AccessRoleDefinition: readonly string[] | { permissions: readonly string[] ; maxDuration?: number ; justification?: boolean ; selfGrant?: string } A role: the permissions it bundles, as type:name, type:* or type:grant.*, on its own type and descendant types. A role may bound the duration of its grants, require a written reason on each, and let holders of a permission of its type grant it to themselves: just-in-time access, which must then be bounded and justified, and which ends no later than the holder’s own grant of that permission.

AccessDirectory

Ƭ AccessDirectory: Object A source-owned table of identity-provider memberships conferring role on (member, object) pairs. index covers [member, object]. A row confers its role only while the source that published it (its source_id) has completed an acquisition, has not lost continuity, and was last observed less than maxAge milliseconds ago, read through ctx.sources.coverage. A removal the provider exposes at time t therefore takes effect by t + maxAge at the latest, whether or not the sync runs, and a decision relying on a membership is valid until its source’s observation is maxAge old. An observation stamped later than the decision’s clock counts as made then, so no decision outlasts maxAge from now. A row without a source, or a context without sources, confers nothing.

Type declaration

Name	Type	Description
`table`	`string`	-
`index`	`string`	-
`type`	`string`	-
`role`	`string`	-
`object`	`string`	-
`member`	`string`	-
`maxAge`	`number`	How old, in milliseconds, the source’s newest observation may be for its rows to confer the role: 1 s to 365 days.

AccessDirectoryCoverage

Ƭ AccessDirectoryCoverage: Pick<SourceCoverage, "acquired" | "observedTo" | "continuityLost"> What a directory’s freshness rule reads of a source’s coverage.

AccessRoleDefinitions

Ƭ AccessRoleDefinitions: Object Roles tenants define as rows of table, each scoped to one object of the scope type, which must be a tenant root type. Defining one needs defineRoles on the scope object and every permission it bundles there, held, for a permission added to a role already granted, at least as long as those grants last; granting one needs grant.custom on the object.

Type declaration

Name	Type
`table`	`string`
`scope`	`string`

RoleDefinitionDocument

Ƭ RoleDefinitionDocument: Object One tenant-defined role: the permissions, as type:name, of a role of type usable on objects under the scope object scope. maxDuration bounds its grants as a declared role’s does: each must expire within it, and recertifying one renews it for at most that long.

Type declaration

Name	Type
`_id`	`GenericId`<`string`>
`scope`	`string`
`type`	`string`
`name`	`string`
`permissions`	`string`[]
`maxDuration?`	`number`

AccessModelDefinition

Ƭ AccessModelDefinition: Object The whole declaration.

Type declaration

Name	Type	Description
`grants?`	`string`	The grants table name. Default `grants`.
`categories?`	`Record`<`string`, `"all"` \| `"any"`>	Restriction categories: `all` requires passing every restricting object of the category, `any` at least one of each set of them an object of the chain carries. Adding a marking to an object’s non-empty `any` set widens it, so it needs `declassify` on each marking the set held as well as `apply` on the new one.
`types`	`Record`<`string`, `AccessTypeDefinition`>	-
`roles`	`Record`<`string`, `AccessRoleDefinition`>	-
`groups?`	{ `types?`: readonly `string`[] ; `depth?`: `number` }	Types whose members can be grant principals, and how deeply group principals may nest (1 to 3).
`groups.types?`	readonly `string`[]	-
`groups.depth?`	`number`	-
`directories?`	readonly `AccessDirectory`[]	-
`roleDefinitions?`	`AccessRoleDefinitions`	-
`claims?`	`Record`<`string`, `AccessClaimType`>	Claims of the verified token the model reads, by name and type. The identity provider asserts them: authentication strength, a declared purpose, the network or device a session came from.
`conditions?`	`Record`<`string`, { `when`: `string` ; `on?`: readonly `string`[] }>	Conditions on claims, by name: `when` in the Cedar expression subset over `context.<claim>`, guarding the listed permissions (`type:name` or `type:*`), or every permission when `on` is omitted. A condition whose claims are absent or of another type refuses. One guarding `T:pass` binds every decision an object of `T` restricts.
`requestScope?`	{ `objects?`: `string` ; `permissions?`: `string` }	Claims narrowing a request below the caller’s grants: `objects` names a claim listing `type:key` objects every decision must fall under, and `permissions` a claim listing the only permissions it may use. Absent claims narrow nothing; a malformed one refuses everything. Neither applies to the pass a restriction decision relies on: its resource is the restricting object, not the decided one.
`requestScope.objects?`	`string`	-
`requestScope.permissions?`	`string`	-
`audit?`	`boolean`	Record decisions made through `audited`, grant changes made through `grant`, `recertify`, `expireGrant` and `revokeAll`, and reminders found due by `reviewDue`, with `log.audit`: who, which object and permission, through which grant or row field, and why.
`users?`	{ `table`: `string` ; `index`: `string` ; `user`: `string` }	Resolve the caller to a local user key through an identity table instead of using `tokenIdentifier` itself. The table is keyed by `tokenIdentifier`, the verified issuer\|subject pair (`index` covers `[tokenIdentifier]`), and `user` names the field holding the local user key: a subject alone would let another issuer’s user of the same subject hold this one’s grants. Grants name the local user, so an issuer change re-associates identity rows and keeps every grant.
`users.table`	`string`	-
`users.index`	`string`	-
`users.user`	`string`	-

AccessCtx

Ƭ AccessCtx: Object The context a rule or helper needs. Every query context satisfies it.

Type declaration

Name	Type	Description
`auth`	`Auth`	-
`db`	`GenericDatabaseReader`<`any`>	-
`sources?`	`Sources`	The coverage of the sources that publish directory rows. Without it, no directory row confers a role.
`audit?`	(`body`: `AuditLogBody`) => `Promise`<`void`>	Where audit records go; `log.audit` unless given.

AccessMutationCtx

Ƭ AccessMutationCtx: Object The context of the grant mutation helpers.

Type declaration

Name	Type
`auth`	`Auth`
`db`	`GenericDatabaseWriter`<`any`>
`scheduler`	`Scheduler`
`audit?`	(`body`: `AuditLogBody`) => `Promise`<`void`>

GrantDocument

Ƭ GrantDocument: Object One stored grant.

Type declaration

Name	Type	Description
`_id`	`GenericId`<`string`>	-
`type`	`string`	-
`object`	`string`	-
`role`	`string`	-
`subjectKind`	`"user"` \| `"group"`	-
`subjectType`	`string`	-
`subject`	`string`	-
`subjectPermission?`	`string`	-
`expiresAt?`	`number`	-
`reason?`	`string`	Why the grant was made, required by roles that ask for one.

AccessPath

Ƭ AccessPath: { via: "grant" ; on: string ; role: string ; principal: string } | { via: "row" ; on: string ; role: string ; field: string } | { via: "directory" ; on: string ; role: string ; table: string ; source: string ; until: number } How a permission was reached, for explain. A directory path names the source that published the membership and the instant its observation becomes too old to rely on.

AccessClaimType

Ƭ AccessClaimType: "String" | "Long" | "Bool" | "Set<String>" | "Set<Long>" The type of a declared claim.

GrantInput

Ƭ GrantInput: Object A grant to insert through grant.

Type declaration

Name	Type
`type`	`string`
`object`	`string`
`role`	`string`
`subject`	{ `user`: `string` } \| { `type`: `string` ; `key`: `string` ; `permission`: `string` }
`expiresAt?`	`number`
`reason?`	`string`

GrantMutation

Ƭ GrantMutation: FunctionReference<"mutation", "internal", { id: GenericId<string> }> A product internal mutation taking a grant’s id.

GrantReminder

Ƭ GrantReminder: Object A review reminder for a bounded grant: notify, the product’s internal mutation, runs before milliseconds ahead of the grant’s expiry (at once when that moment has passed) with the grant’s id. It calls reviewDue and commits the notice.

Type declaration

Name	Type
`before`	`number`
`notify`	`GrantMutation`

GrantOptions

Ƭ GrantOptions: Object How grant and recertify schedule a bounded grant’s lapse, through expire, the product’s export of expireGrant, and its review reminder.

Type declaration

Name	Type
`expire?`	`GrantMutation`
`remind?`	`GrantReminder`

AccessModel

Ƭ AccessModel: ReturnType<typeof buildModel> The declared model and everything derived from it.

AccessCedarPolicies

Ƭ AccessCedarPolicies: Object A model compiled to Cedar: a schema in Cedar’s schema syntax, one template per role and the static policies, all in Cedar’s policy syntax. They depend on the declaration only.

Type declaration

Name	Type
`schema`	`string`
`templates`	`Record`<`string`, `string`>
`policies`	`Record`<`string`, `string`>

AccessCedarUid

Ƭ AccessCedarUid: Object A Cedar entity reference in Cedar’s JSON format.

Type declaration

Name	Type
`type`	`string`
`id`	`string`

AccessCedarEntities

Ƭ AccessCedarEntities: Object The Cedar data a world of rows determines, in Cedar’s JSON formats: the entities, one template per tenant-defined role and scope, and one template link per live grant or directory row.

Type declaration

Name	Type
`templates`	`Record`<`string`, `string`>
`entities`	{ `uid`: `AccessCedarUid` ; `attrs`: `Record`<`string`, `unknown`> ; `parents`: `AccessCedarUid`[] }[]
`templateLinks`	{ `templateId`: `string` ; `newId`: `string` ; `values`: { `?principal`: `AccessCedarUid` ; `?resource`: `AccessCedarUid` } }[]

ServiceName

Ƭ ServiceName: "ai-gateway" A Bijection-managed service. The backend decides which names it accepts; this type lists the ones the current release knows about.

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.

IntegrationAddress

Ƭ IntegrationAddress: Object

Type declaration

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

SourceBinding

Ƭ SourceBinding: Object

Type declaration

Name	Type
`version`	`1`
`integration`	`IntegrationAddress`
`collection`	`string`

WirePath

Ƭ WirePath: readonly string[] Paths select own wire-object fields, never arbitrary guest expressions.

HttpArgumentReference

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

Type declaration

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

HttpInputReference

Ƭ HttpInputReference: { input: "checkpoint" | "resume" | "operation_id" | "expires_at" | "target_version" } | { input: "target_key" ; path?: WirePath } | { input: "created_key" } | HttpArgumentReference | { input: "parameter" ; path?: WirePath }

HttpInput

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

HttpTemplate

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

Selector

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

BodyContract

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

ResponseContract

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

Type declaration

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

ScalarValue

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

KeyEncoding

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

KindMatch

Ƭ KindMatch: Object

Type declaration

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

RecordKindSource

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

KeyPart

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

RecordKeySource

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

ResumeSource

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

RecordProjection

Ƭ RecordProjection: Object

Type declaration

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

HttpEvidence

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

HttpContract

Ƭ HttpContract: Object

Type declaration

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

ResponseEvidence

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

IntegrationContext

Ƭ IntegrationContext<H>: Object

Type parameters

Name	Type
`H`	extends `HttpContracts` = `HttpContracts`

Type declaration

Name	Type
`http`	{ `request`: <N>(`contract`: `N`, `parameters?`: `HttpParameters`<`H`[`N`]>) => `Promise`<`HttpOutcome`<`H`[`N`]>> }
`http.request`	[object Object]

SourceProtocol

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

MeasurementShape

Ƭ MeasurementShape: { shape: "twin_hot" } | { shape: "twin_cold" ; dwell_ms: number } | { shape: "window" ; definition: string ; revision: number ; window_ms: number ; lateness_ms: number } | { shape: "late_observation" } | { shape: "occurrence_log" } | { shape: "refusal" } Which of the shapes a measurement collection holds. Each is a different bound on the same quantity. The two twin shapes revise one row per key; the other three append a row and are bounded by what produces them — a closed interval, a transition, or a refusal.

CoupledResult

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

Type parameters

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

CouplingDefinition

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

Type parameters

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

Type declaration

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

ListenerProtocol

Ƭ ListenerProtocol: { kind: "queue" ; provider: "sqs" ; visibility_seconds: number ; wait_seconds: number ; poll_interval_ms: number ; proves: "refresh_hint" } | { kind: "socket" ; open: string ; address: Selector ; envelope: readonly string[] ; frame_kind: readonly string[] ; disconnect: string ; acknowledge: string ; max_frame_bytes: number ; proves: "refresh_hint" } | { kind: "push" ; ingress: ListenerIngress ; subscription?: { channel: { resource: readonly string[] ; proof: { channel_id: Selector ; resource_id: Selector ; resource_uri: Selector ; expiration: Selector } ; matching: { tolerated_query?: readonly string[] ; lifetime_ms: number ; renewal_margin_ms: number } } ; watch: string ; stop: string } } | { kind: "pull" ; poll: string ; interval_ms: number ; min_interval_ms: number ; max_interval_ms: number ; continuation: { kind: "validator" ; request_header: string ; response_header: string ; interval_header?: string ; quiet_status: number } | { kind: "cursor" ; parameter: string ; resume: ResumePrefix ; retention: Retention } ; position: { items?: readonly string[] ; id: readonly string[] ; order: "decimal" | "opaque" | "opaque_ascending" } ; keys?: { list: string ; items?: readonly string[] ; id?: readonly string[] ; parameter: string ; partition: readonly string[] } } How change hints reach the engine for one collection, and the whole of what a listener declares. The variant is the transport class and it carries what that transport needs. push has an ingress endpoint because the provider delivers to one; pull has none, because nothing is delivered to it. Neither is an optional field a declaration could leave empty. A delivery, and equally a poll, is a refresh hint only: it asks the engine to read again and proves nothing by itself. A listener’s collection declares its own sync, because a hint asks for acquisition and there has to be one to ask for.

CollectionDefinition

Ƭ CollectionDefinition<S, H, P>: CollectionShape<S, P> & { sync: { every: SyncEvery ; read: (ctx: IntegrationContext<H>, input: ProtocolInput<P>) => Promise<ProtocolResult<P, ObjectType<S>>> } } A collection acquired on its own: it declares its own interval and its own reader.

Type parameters

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

CoupledCollectionDefinition

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

Type parameters

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

CommandCondition

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

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.

CommandTarget

Ƭ CommandTarget: GenericId<string> | { sourceId: string } Existing records use their local ID. Creates address one installed source, including when several accounts populate the same table. The host enforces the target kind against the command declaration and rechecks its binding.

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`	`CommandDefinition`<`Fields`, `Record`<`string`, `Fields`>>[`"delivery"`]	Native retained deduplication and expiry assumptions. Product policy can require these independently of conditional comparison.
`phase`	`"review"` \| `"acceptance"` \| `"send"`	-
`requester`	`string`	-
`target`	`CommandTarget`	-
`args`	`Value`	-
`approval`	`null` \| { `id`: `string` ; `approver`: `string` ; `beneficiary`: `string` }	-

CommandGoverningDefinition

Ƭ CommandGoverningDefinition: FunctionReference<"query", "public" | "internal", any, CommandGoverningResult> | { query: FunctionReference<"query", "public" | "internal", any, CommandGoverningResult> ; reads: readonly string[] } A command policy may read named private inputs at review, admission and send. Only its decision is released; reads do not become caller authority. Commands always evaluate the current final basis.

CommandStates

Ƭ CommandStates<A>: Object The change a record-targeted command’s send REQUESTS of its target record, field by field: each key is a field of the target collection’s schema, and each value is the path into this command’s arguments whose value the request asks that field to take. Every path names REQUIRED arguments, and the argument’s type must be one the field admits. It is read only on a branch, where nothing is delivered: a held call whose command states its change is shown there as that change, with assumed provenance, so the branch’s views show its consequence. It never becomes evidence that the destination applied anything, and fields the provider computes — assigned identifiers, totals — are not stated and stay as last observed. A create cannot state a change: its record’s key is the provider’s to assign.

Type parameters

Name	Type
`A`	extends `Fields`

Index signature

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

CommandDefinition

Ƭ CommandDefinition<A, S, H>: CommandShape<A, S> & { creates?: undefined ; states?: CommandStates<A> ; send: (ctx: IntegrationContext<H>, input: CommandInput<A>) => Promise<CommandResult<S>> ; reconcile: (ctx: IntegrationContext<H>, input: Omit<CommandInput<A>, "expires_at">) => Promise<CommandResult<S>> } | CommandShape<A, S> & { creates: { kind: "deduplicated" } | { kind: "stored" } | { kind: "unattributed" } ; states?: undefined ; send: (ctx: IntegrationContext<H>, input: CreateCommandInput<A>) => Promise<CommandResult<S>> ; reconcile: (ctx: IntegrationContext<H>, input: Omit<CreateCommandInput<A>, "expires_at">) => Promise<CommandResult<S>> } One command. The two arms differ in exactly one fact and everything else follows from it: whether the send addresses a RECORD of the target collection or the COLLECTION itself. A record-targeted command’s handlers receive that record’s key; a create’s do not, because the record does not exist yet, and they receive the operation’s own identity instead.

Type parameters

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

CommandHandle

Ƭ CommandHandle<Args>: Object

Type parameters

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

Type declaration

Name	Type
`[commandExport]`	() => { `version`: `1` ; `integration`: `IntegrationAddress` ; `command`: `string` }
`__commandArgs?`	`Args`

CommandArgs

Ƭ CommandArgs<C>: C extends CommandHandle<infer Args> ? Args : never

Type parameters

Name	Type
`C`	extends `CommandHandle`<`any`>

ApprovalId

Ƭ ApprovalId: GenericId<"_approvals">

ExternalCallId

Ƭ ExternalCallId: string & { __externalCallId: unique symbol }

SourceCoverage

Ƭ SourceCoverage: Object 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.

Type declaration

Name	Type	Description
`acquired`	`boolean`	Whether an initial acquisition has completed. `false` is not an empty population. It is the absence of any completed acquisition, which is what makes “this source is covered and holds nothing” and “we cannot establish whether this source holds anything” different answers instead of the same empty page.
`observedFrom`	`number` \| `null`	The beginning of the window the current coverage publishes, in epoch milliseconds. It moves only when a completed acquisition publishes coverage, so it is the last publication that changed what this source says. `null` until an acquisition completes.
`observedTo`	`number` \| `null`	The newest observation the coverage extends to, in epoch milliseconds. An unchanged answer advances this without moving `observedFrom`.
`age`	`number` \| `null`	The age of that newest observation, in milliseconds.
`continuityLost`	`boolean`	Whether continuity was lost. The coverage still proves what it proved and can no longer be extended.
`checkedAt`	`number` \| `null`	The last check this source answered successfully, in epoch milliseconds. Later than `observedFrom` means the source was asked again and nothing had changed.
`refreshOutstanding`	`boolean`	Whether a refresh responsibility is still outstanding.
`dataset?`	{ `lastCompleteVersion`: `string` \| `null` ; `targetVersion`: `string` \| `null` ; `coherent`: `boolean` ; `checkpoint`: { `kind`: `"uninitialized"` } \| { `kind`: `"published"` ; `version`: `string` } \| { `kind`: `"moving"` ; `base`: `string` \| `null` ; `target`: `string` ; `cursor`: { `bucket`: `number` ; `afterKey`: `string` \| `null` } ; `rebase`: `boolean` } \| { `kind`: `"rebase_ready"` } \| { `kind`: `"erasing"` \| `"erased"` } \| { `kind`: `"confirming"` ; `target`: `string` ; `after`: `string` \| `null` } ; `gap`: `"base_unavailable"` \| `"target_retired"` \| `"binding_changed"` \| `"projection_withheld"` \| `"bucket_bound"` \| `"retention_released"` \| `null` }	Exact dataset basis when this is a dataset-backed source. `coherent` is false while pages of a new version are being published or a gap is held; its rows may then be a mix of the last complete and target versions.
`dataset.lastCompleteVersion`	`string` \| `null`	-
`dataset.targetVersion`	`string` \| `null`	-
`dataset.coherent`	`boolean`	-
`dataset.checkpoint`	{ `kind`: `"uninitialized"` } \| { `kind`: `"published"` ; `version`: `string` } \| { `kind`: `"moving"` ; `base`: `string` \| `null` ; `target`: `string` ; `cursor`: { `bucket`: `number` ; `afterKey`: `string` \| `null` } ; `rebase`: `boolean` } \| { `kind`: `"rebase_ready"` } \| { `kind`: `"erasing"` \| `"erased"` } \| { `kind`: `"confirming"` ; `target`: `string` ; `after`: `string` \| `null` }	The exact durable page or confirmation position used for the next read.
`dataset.gap`	`"base_unavailable"` \| `"target_retired"` \| `"binding_changed"` \| `"projection_withheld"` \| `"bucket_bound"` \| `"retention_released"` \| `null`	-

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.

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.

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`

SourceHandle

Ƭ SourceHandle<S>: Object

Type parameters

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

Type declaration

Name	Type	Description
`schema`	`S`	-
`__sourceType?`	`ObjectType`<`S`>	Phantom shape used to check the destination table’s validator.

ConnectionBudget

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

BackoffRepresentation

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

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

ConnectionBackoff

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

Type declaration

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

ReplicationTransport

Ƭ ReplicationTransport: Record<string, never> A PostgreSQL logical replication slot, pgoutput protocol v1. Physical relation names, publication and credentials are private installation configuration and are never declared here.

MailboxTransport

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

Type declaration

Name	Type
`provider`	`"imap"`
`messages`	`string`
`contents`	`string`
`memberships`	`string`

StreamTransport

Ƭ StreamTransport: Object One device stream. The broker address, its partitions and its credentials are private installation configuration; a declaration names only the topic and the four record fields the engine reads. correlation is the field a device’s acknowledgement carries its command’s operation identity in: a protocol that omits it declares that it does not acknowledge, and a command against such a protocol is refused rather than confirmed from a later reading. The batch cadence is each collection’s own every, exactly as it is for the other host-executed transports, so a hot twin’s declared revision rate has one owner rather than a second number here.

Type declaration

Name	Type	Description
`encoding`	{ `kind`: `"json"` } \| { `kind`: `"avro"` }	-
`topic`	`string`	-
`key`	`string`	-
`event_time`	`string`	-
`value`	`string`	-
`correlation?`	`string`	-
`command_topic?`	`string`	The topic this group’s commands are produced to. A group declaring it delivers its commands over this transport rather than through an HTTP contract: one broker, one connection, one credential, and no second outbound address on the same installed source. It requires `correlation`, because a command whose acknowledgement has no field to arrive on would leave every call unknown for ever, and it is never the topic this group consumes, because one topic carrying both directions would route a command’s own record back to it as its own acknowledgement.

AcquisitionTransport

Ƭ AcquisitionTransport: { transport: "replication" ; value: ReplicationTransport } | { transport: "mailbox" ; value: MailboxTransport } | { transport: "stream" ; value: StreamTransport } | { transport: "dynamo_db" ; value: { collection: string } } | { transport: "git" ; value: { collection: string } } | { transport: "big_query" ; value: { collection: string } } | { transport: "sheets" ; value: { collection: string } } | { transport: "kubernetes" ; value: { collection: string } } | { transport: "bayeux" ; value: BayeuxTransport } | { transport: "mongo" ; value: { collection: string ; fields: Record<string, string> ; max_initial_rows: number } } | { transport: "sql" ; value: SqlTransport } | { transport: "dataset" ; value: DatasetTransport } | { transport: "bijection" ; value: BijectionTransport } | { transport: "sftp" ; value: SftpTransport } | { transport: "odata" ; value: ODataTransport } The declared transport. The discriminator is spelled transport because that is what it selects; there is no acquisition kind beside it.

SyncInput

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

FeedInput

Ƭ FeedInput: Object

Type declaration

Name	Type
`checkpoint`	`string`

IncrementalInput

Ƭ IncrementalInput: Object

Type declaration

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

EnumerationInput

Ƭ EnumerationInput: Object

Type declaration

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

SweepInput

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

Type declaration

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

CoupledInput

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

Type declaration

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

ChangeFeedResult

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

Type parameters

Name
`T`

Type declaration

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

Observation

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

Type parameters

Name
`T`

RecordResult

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

Type parameters

Name
`T`

RecordObservation

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

Type parameters

Name
`T`

TransactionMetric

Ƭ TransactionMetric: Object Used and remaining amounts for a single transaction limit.

Type declaration

Name	Type
`used`	`number`
`remaining`	`number`

TransactionMetrics

Ƭ TransactionMetrics: Object The remaining headroom for a transaction before hitting limits. See https://docs.bijection.com/production/state/limits

Type declaration

Name	Type
`bytesRead`	`TransactionMetric`
`bytesWritten`	`TransactionMetric`
`databaseQueries`	`TransactionMetric`
`documentsRead`	`TransactionMetric`
`documentsWritten`	`TransactionMetric`
`functionsScheduled`	`TransactionMetric`
`scheduledFunctionArgsBytes`	`TransactionMetric`

FunctionMetadata

Ƭ FunctionMetadata: Object Metadata about the currently executing Bijection function.

Type declaration

Name	Type	Description
`name`	`string`	The name of the function, in the format `"path/to/module:functionName"`
`componentPath`	`string`	The path of the component this function belongs to. This is an empty string `""` for the app.
`type`	`FunctionType`	Whether it’s a query, mutation, or action.
`visibility`	`FunctionVisibility`	Whether the function is public or internal.

DeploymentMetadata

Ƭ DeploymentMetadata: Object Metadata about the deployment this function is running on.

Type declaration

Name	Type	Description
`name`	`string`	The deployment name, e.g. `"tall-tiger-123"` for cloud deployments, `"local-my_team-my_project"` for local deployments, or `"anonymous-*"` for anonymous deployments.
`region`	`string` \| `null`	The deployment region, e.g. `"aws-us-east-1"`. `null` for local and self-hosted deployments.
`class`	`"s16"` \| `"s256"` \| `"d1024"` \| `"d2048"`	The deployment class, e.g. `"s16"`, `"s256"`, `"d1024"`, or `"d2048"`.

RequestMetadata

Ƭ RequestMetadata: Object Metadata about the HTTP request that triggered the current function execution. ip and userAgent are null when the function was not triggered by an HTTP request (e.g. scheduled jobs or cron jobs). Functions called from within a function (i.e. using runMutation or runAction) will have the same request metadata as the parent function.

Type declaration

Name	Type	Description
`ip`	`string` \| `null`	-
`userAgent`	`string` \| `null`	-
`requestId`	`string`	-
`scheduledFunctionId`	`string` \| `null`	The ID of the scheduled function document (in `_scheduled_functions`) that this execution belongs to, or `null` otherwise. This is set for the scheduled function itself and for any functions it calls (e.g. a mutation invoked via `runMutation` by a scheduled action), propagating the top-level scheduled function’s ID down the call tree. It is `null` when the function was not scheduled.
`authToken`	`string` \| `null`	The raw auth token (a JWT) the request was authenticated with, or `null` when the request was unauthenticated or authenticated with an admin key. This is the same token that `ctx.auth.getUserIdentity()` derives its attributes from.

OperationInterfaceContract

Ƭ OperationInterfaceContract: Object A shared operation shape. The concrete operation supplies its target ID domain and all execution/authorization behavior.

Type declaration

Name	Type
`version`	`1`
`name`	`string`
`args`	`ValidatorJSON`
`returns`	`ValidatorJSON`

OperationContract

Ƭ OperationContract: Object The analyzed business contract paired with a generated operation reference. It identifies a declaration and grants no authority.

Type declaration

Name	Type
`version`	`1`
`operation`	`string`
`visibility`	`"public"` \| `"internal"`
`on`	`string`
`target?`	{ `argument`: `string` }
`target.argument`	`string`
`interfaces?`	`OperationInterfaceContract`[]
`consumes?`	`PublicationConsumption`
`args`	`ValidatorJSON`
`returns`	`ValidatorJSON`

OperationContractMetadata

Ƭ OperationContractMetadata: Object A contract and the digest carried by its generated reference.

Type declaration

Name	Type
`contract`	`OperationContract`
`contract_digest`	`string`

OperationImplementation

Ƭ OperationImplementation<Args, Result>: Object Protected discovery returns concrete, recoverable operation addresses. The phantom fields preserve the shared argument/result types.

Type parameters

Name	Type
`Args`	extends `DefaultFunctionArgs`
`Result`	`Result`

Type declaration

Name	Type
`component`	`string`
`contract_json`	`string`
`contract_digest`	`string`
`_interfaceArgs`	`Args`
`_interfaceResult`	`Result`

OperationInterfaceDefinition

Ƭ OperationInterfaceDefinition<Args, Result>: RegisteredQuery<"public", { on?: string }, Promise<OperationImplementation<Args, Result>[]>> & { } A shared capability and its ordinary discovery query. It supplies no storage, target authority, approvals or implementation.

Type parameters

Name	Type
`Args`	extends `DefaultFunctionArgs`
`Result`	`Result`

ComponentOperationManifest

Ƭ ComponentOperationManifest: Record<string, OperationContractMetadata & { functions: Record<"invoke" | "preview" | "recover" | "status" | "revise", string> }> Generated component exports bind a contract to each actual adapter address.

OperationReference

Ƭ OperationReference<Visibility, Args, LocalResult, ComponentPath>: Object A generated business operation reference. This is distinct from an ordinary query, mutation or action reference.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility` = `"public"`
`Args`	extends `DefaultFunctionArgs` = `any`
`LocalResult`	`any`
`ComponentPath`	`string` \| `undefined`

Type declaration

Name	Type
`_kind`	`"operation"`
`_visibility`	`Visibility`
`_args`	`Args`
`_returnType`	`LocalResult`
`_componentPath`	`ComponentPath`

OperationArgs

Ƭ OperationArgs<Operation>: Operation["_args"] Arguments inferred from an operation reference.

Type parameters

Name	Type
`Operation`	extends `OperationReference`<`any`, `any`, `any`>

OperationLocalResult

Ƭ OperationLocalResult<Operation>: Operation["_returnType"] The operation’s validated local result, independent of remote outcomes.

Type parameters

Name	Type
`Operation`	extends `OperationReference`<`any`, `any`, `any`>

OperationInvocationId

Ƭ OperationInvocationId: string & { __operationInvocationId: unique symbol } An accepted business invocation’s opaque identity. It is a locator and grants no permission to read or change that invocation.

OperationAcceptance

Ƭ OperationAcceptance<LocalResult>: Object Evidence that the local preparation committed. This does not establish a provider’s application of any external call.

Type parameters

Name	Type
`LocalResult`	`any`

Type declaration

Name	Type
`invocation_id`	`OperationInvocationId`
`accepted_revision`	`bigint`
`target?`	{ `view`: `string` ; `id`: `string` }
`target.view`	`string`
`target.id`	`string`
`local_result`	`LocalResult`
`definition_digest`	`string`

OperationRecovery

Ƭ OperationRecovery<LocalResult>: { kind: "absent" } | { kind: "accepted" } & OperationAcceptance<LocalResult> Recovery inspects the original request; an absent result does not itself authorize submitting different arguments or a new request identity.

Type parameters

Name	Type
`LocalResult`	`any`

OperationPreview

Ƭ OperationPreview<LocalResult>: Object A native evaluation result on one provisional basis. It grants no approval, acceptance, reservation or permission to execute later.

Type parameters

Name	Type
`LocalResult`	`any`

Type declaration

Name	Type	Description
`kind`	`"preview"`	-
`basis_revision`	`bigint`	-
`contract_digest`	`string`	-
`is_complete`	`boolean`	-
`is_executable`	`boolean`	-
`is_disclosure_complete`	`boolean`	-
`is_result_complete`	`boolean`	-
`checks`	`Record`<`"preparation"` \| `"constraints"` \| `"governing"` \| `"invocation"`, `"satisfied"` \| `"denied"` \| `"unevaluated"`>	-
`arguments?`	`Value`	-
`local_result?`	`LocalResult`	-
`changes`	{ `component`: `string` ; `table`: `string` ; `id`: `string` ; `before`: `Value` ; `after`: `Value` ; `is_derived`: `boolean` }[]	-
`external_calls`	{ `integration`: `string` ; `command`: `string` ; `target`: `string` ; `args`: `Value` ; `outcome`: `"unevaluated"` }[]	-
`refusal`	{ `code`: `string` ; `message`: `string` } \| `null`	The operation’s own declared refusal, when its preparation threw one: a `BijectionError` whose data carries a string `code` and `message`, repeated exactly as submitting the same request would return them and after the same check of what the preparation read. Only those two fields; null for any other failure, whose details a preview withholds.

OperationReviewState

Ƭ OperationReviewState: { kind: "none" } | { kind: "awaiting_review" ; operation: string ; blocker: string ; responsible: string ; since: bigint | null } | { kind: "waiting" ; operation: string ; blocker: string ; responsible: string ; until: bigint | null } | { kind: "approved" ; approval: string ; approved_by: string ; beneficiary: string ; decided_at: number ; expires_at: bigint } | { kind: "awaiting_approval" ; approval: string ; approved_by: string ; beneficiary: string ; expires_at: bigint } | { kind: "rejected" ; approval: string ; approved_by: string ; beneficiary: string } Whether a request is held, and who must act. Every variant is derived from a retained row at read time: the approval the request consumed, or the refusal the ordinary dispatch evaluator returns for one of its external calls. No variant is inferred from how long a request has been waiting. Instants are epoch milliseconds: exact bigint where the engine stores an integer, and number for decided_at, which is the row’s own _creationTime.

OperationStatus

Ƭ OperationStatus: Omit<OperationAcceptance, "local_result"> & { external_calls: { id: string ; delivery: "pending" | "held" | "unknown" | "delivered" | "refused" | "indeterminate" | "delivered_unacknowledged" | "not_applied" | "duplicated" | "superseded" ; publication: null | { kind: "pending" } | { kind: "blocked" } | { kind: "published" ; revision: bigint } }[] ; summary: { total: bigint ; pending: bigint ; unknown: bigint ; refused: bigint ; delivered: bigint ; superseded: bigint ; delivered_unacknowledged: bigint ; publication_pending: bigint ; not_applied: bigint ; duplicated: bigint } ; review: OperationReviewState } The retained state of one accepted request: its acceptance identity, the delivery and publication state of each external call it accepted, and its review state. Delivery values describe local knowledge of the destination, never proof that the provider applied anything. Status excludes the original business result. Recovering that result requires retained content protection; status rechecks current authority without releasing the earlier content.

OperationErrorCode

OperationErrorData

Ƭ OperationErrorData: Object Native invocation error data carried by the ordinary BijectionError. This identifies the refused boundary; it does not describe an external outcome.

Type declaration

Name	Type
`kind`	`"operation_error"`
`code`	`OperationErrorCode`

OperationFunctionReferences

Ƭ OperationFunctionReferences<Visibility, Args, LocalResult>: Object Actual generated adapter addresses, for components with explicit export mappings. No companion address is inferred from an arbitrary component alias.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility` = `"public"`
`Args`	extends `DefaultFunctionArgs` = `any`
`LocalResult`	`any`

Type declaration

Name	Type	Description
`invoke`	`FunctionReference`<`"mutation"`, `Visibility`, { `request_key`: `string` ; `args`: `Args` ; `expected_contract`: `string` }, `OperationAcceptance`<`LocalResult`>>	-
`preview`	`FunctionReference`<`"mutation"`, `Visibility`, { `args`: `Args` ; `expected_contract`: `string` }, `OperationPreview`<`LocalResult`>>	-
`recover`	`FunctionReference`<`"query"`, `Visibility`, { `request_key`: `string` ; `args`: `Args` ; `expected_contract`: `string` }, `OperationRecovery`<`LocalResult`>>	-
`status`	`FunctionReference`<`"query"`, `Visibility`, { `expected_contract`: `string` } & { `invocation_id`: `string` } \| { `request_key`: `string` ; `args`: `Args` }, `OperationStatus`>	-
`revise`	`FunctionReference`<`"mutation"`, `Visibility`, { `invocation_id`: `string` ; `expected_contract`: `string` }, `OperationRevision`>	Re-admits an accepted request’s never-held external calls under their destinations’ current revisions.

OperationRevision

Ƭ OperationRevision: Object What revise reports: which of a request’s external calls were re-stamped onto the current contract, and which already named it. A call that was ever held is not in either list — it refuses, and the whole revision with it.

Type declaration

Name	Type
`kind`	`"revised"`
`restamped`	`string`[]
`unchanged`	`string`[]

OperationDefinition

Ƭ OperationDefinition<Visibility, Args, LocalResult>: { isOperation: true } & Visibility extends "public" ? { isPublic: true } : { isInternal: true } A business declaration lowered to ordinary transactional mutation and query execution. Its object association supports discovery and grants no authority.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility`
`Args`	extends `DefaultFunctionArgs`
`LocalResult`	`LocalResult`

OperationBuilder

Ƭ OperationBuilder<DataModel, Visibility>: <ArgsValidator, ReturnsValidator>(definition: { on: ViewDefinition<any, any, any> | TableDefinition<any, any, any, any, false> ; target?: { argument: string } ; implements?: readonly OperationInterfaceDefinition<any, any>[] ; consumes?: PublicationConsumption ; args: ArgsValidator ; returns: ReturnsValidator ; prepare: (ctx: BijectionMutationCtx<DataModel>, args: OperationArgsFromValidator<ArgsValidator>) => ReturnValueForOptionalValidator<ReturnsValidator> }) => OperationDefinition<Visibility, OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Visibility`	extends `FunctionVisibility`

Type declaration

▸ <ArgsValidator, ReturnsValidator>(definition): OperationDefinition<Visibility, OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>> The schema-specific type used by generated server utilities.

Type parameters

Name	Type
`ArgsValidator`	extends `OperationArgsValidator`
`ReturnsValidator`	extends `OperationReturnValidator`

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.on`	`ViewDefinition`<`any`, `any`, `any`> \| `TableDefinition`<`any`, `any`, `any`, `any`, `false`>	-
`definition.target?`	`Object`	Explicit selected-object argument; discovery never guesses from names.
`definition.target.argument`	`string`	-
`definition.implements?`	readonly `OperationInterfaceDefinition`<`any`, `any`>[]	-
`definition.consumes?`	`PublicationConsumption`	-
`definition.args`	`ArgsValidator`	-
`definition.returns`	`ReturnsValidator`	Defines the public local result type and validates preparation, independently of a particular handler’s narrower result or any remote outcome.
`definition.prepare`	(`ctx`: `BijectionMutationCtx`<`DataModel`>, `args`: `OperationArgsFromValidator`<`ArgsValidator`>) => `ReturnValueForOptionalValidator`<`ReturnsValidator`>	-

Returns

OperationDefinition<Visibility, OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>>

Cursor

Ƭ Cursor: string An opaque identifier used for paginating a database query. Cursors are returned from paginate and represent the point of the query where the page of results ended. To continue paginating, pass the cursor back into paginate in the PaginationOptions object to fetch another page of results. Note: Cursors can only be passed to exactly the same database query that they were generated from. You may not reuse a cursor between different database queries.

PublicationConsumption

Ƭ PublicationConsumption: Object Enforced by the native reader before the declared function body runs.

Type declaration

Name	Type	Description
`tables`	readonly `string`[]	-
`compatibility`	`"sameGroup"` \| `"sharedRoots"`	-
`covers?`	readonly { `table`: `string` ; `argument`: `string` }[]	Each argument must be a required string containing a native checkpoint. `table` names an input relation whose processing is required.

PublicationRequirement

Ƭ PublicationRequirement: Object A transaction-local requirement, using concrete native checkpoint values.

Type declaration

Name	Type
`tables`	readonly `string`[]
`compatibility`	`"sameGroup"` \| `"sharedRoots"`
`covers?`	readonly { `table`: `string` ; `after`: `string` }[]

PublicationReadiness

Ƭ PublicationReadiness: { kind: "ready" } | { kind: "pending" ; reason: "PublishedUnavailable" | "PublicationUnavailable" | "PublicationSourceUnavailable" | "PublicationGroupMismatch" | "PublicationEvidenceUnavailable" | "PublicationRootMismatch" | "PublicationRootOverlap" | "PublicationCoverage" } Current native serving state under this query’s read and access dependencies.

PublicationEvidence

Ƭ PublicationEvidence: { kind: "unknown" } | { kind: "certified" ; roots: { table: string ; source: string | null ; readBasis: string ; observedFrom: string | null ; observedTo: string | null }[] ; partitionedRoots: number }

PublicationCapture

Ƭ PublicationCapture: Object A page read and attested by the native database owner.

Type declaration

Name	Type
`rows`	`Record`<`string`, `any`>[]
`cursor`	`string` \| `null`
`isDone`	`boolean`
`witness`	`string`

PublicationServing

Ƭ PublicationServing: { kind: "unmanaged" } | { kind: "transitioning" ; publisher: string | null ; producer: string | null ; retired: boolean ; isInitial: boolean } | { kind: "serving" | "withdrawn" ; publisher: string ; producer: string ; group: string ; selection: string ; run: string ; evidence: PublicationEvidence }

PublisherScanRefusal

Ƭ PublisherScanRefusal: "manifestFailed" | "manifestInvalid" | "undeclaredProducer" | "relationOwnedElsewhere" | "servingUnverifiable" Why the native publisher scan cannot use the producer’s declaration.

PublicationStatus

Ƭ PublicationStatus: Object

Type declaration

Name	Type	Description
`serving`	`PublicationServing` \| `null`	-
`publishedAt`	`string` \| `null`	-
`scan`	`null` \| { `refusal`: `PublisherScanRefusal` }	Set while the native scan refuses the declaration producing this relation, so no preparation can start or continue.
`preparation`	`null` \| { `state`: { `kind`: `"open"` \| `"sealed"` \| `"validating"` \| `"validated"` } \| { `kind`: `"published"` ; `revision`: `string` } \| { `kind`: `"refused"` ; `reason`: `string` } ; `rows`: `number` ; `pages`: `number` }	-

SerializedPublished

Ƭ SerializedPublished: Object The wire form of one published-relation declaration, exactly as the deployment compiler decodes it.

Type declaration

Name	Type
`version`	`1`
`producer`	`string`
`member`	`string`

PublisherDefinition

Ƭ PublisherDefinition: Object A publisher a business program declares. A published relation’s rows are the engine’s to write. Something has to tell the engine what to write, and it cannot be a syscall: opening a receipt grants no authority, and a guest mutation’s transaction carries the guest’s identity. So the direction is inverted. The program declares three internal queries, the engine reads them under its own identity, and it verifies every byte it is handed before any of it reaches a relation.

manifest, a query answering which runs are ready to publish: for each, the producer, the execution basis the transform ran under, how many steps it took and the output members with their row and byte counts. It is read inside the engine’s scan transaction, so the rows it reads become the publisher’s region set: a committed write that makes a run ready is what wakes the driver, and between runs nothing runs.
steps, a query paging one ready run’s step records — each step’s state, its input digest, its continuation and the sealed receipt token the engine re-opens for itself.
page, a query paging one output member’s staged rows in key order.

All three names are resolved against the deployment at push — a declaration naming a function the deployment does not declare is refused there — and they are resolved again in the transaction that drives a step, because a publisher outlives the push that created it. The separate rebuild internal mutation records desired state after an ownership transition. It uses the ordinary commit path and receives no publication authority; the native driver still owns the binding switch.

export const warehouse = definePublisher({
  producer: "warehouse",
  manifest: internal.etl.readyPublications,
  steps: internal.etl.publicationSteps,
  page: internal.etl.publicationPage,
  rebuild: internal.etl.deployment,
});

Type declaration

Name	Type
`isPublisher`	`true`

ReadAccessRequest

Ƭ ReadAccessRequest: Infer<typeof requests>[number] One native object or searched-domain authorization obligation.

ReadAccessArgs

Ƭ ReadAccessArgs: Object The complete batch passed to a scoped read authorization query.

Type declaration

Name	Type
`requests`	`ReadAccessRequest`[]

ReadAccessResult

Ƭ ReadAccessResult: null | { validUntil: number ; reason?: string } | { reason: string } One request’s result: null permits it with no clock-dependent expiry, { validUntil } permits it until then. A permission may also say why it permits, { reason } or { validUntil, reason }: a string of at most 256 UTF-8 bytes, which permits exactly as the same result without it. The engine records it on its audit line of an audited table (.access(\{ audit: true \}), which covers the table’s read, disclose and write rules) and never shows it to the caller; a longer or non-string reason refuses. Throw to refuse. A rule says why it refuses with throw new BijectionError({ kind: "AccessRefused", why }), which the audit line records (cut to 256 bytes); the caller of a rule that declares its inputs sees only the engine’s fixed refusal.

ReadAccessResults

Ƭ ReadAccessResults: ReadAccessResult[] What every rule returns: one result per item it decides, in order — per request for a read or disclosure rule, per change for a table’s write rule (.govern, [] for no change), and a one-element list for an integration command’s rule. The engine refuses the batch unless every item has a permitting result, so an item a rule never looked at is refused rather than permitted. A bare null, and a rule that falls off its end (which reaches the engine as null), refuses. A rule that permits without looking must say so for each item.

DisclosureArgs

Ƭ DisclosureArgs: Object Native fixed-output disclosure request.

Type declaration

Name	Type
`requests`	`ReadAccessRequest`[]
`destination`	`Infer`<typeof `destination`>

GenericMutationCtxWithTable

Ƭ GenericMutationCtxWithTable<DataModel>: Omit<GenericMutationCtx<DataModel>, "db"> & { db: GenericDatabaseWriterWithTable<DataModel> } A set of services for use within Bijection mutation functions. The mutation context is passed as the first argument to any Bijection mutation function run on the server. You should generally use the MutationCtx type from "./_generated/server".

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

GenericQueryCtxWithTable

Ƭ GenericQueryCtxWithTable<DataModel>: Omit<GenericQueryCtx<DataModel>, "db"> & { db: GenericDatabaseReaderWithTable<DataModel> } A set of services for use within Bijection query functions. The query context is passed as the first argument to any Bijection query function run on the server. This differs from the MutationCtx because all of the services are read-only.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

DefaultFunctionArgs

Ƭ DefaultFunctionArgs: Record<string, unknown> The default arguments type for a Bijection query, mutation, or action function. Bijection functions always take an arguments object that maps the argument names to their values.

ArgsArray

Ƭ ArgsArray: OneArgArray | NoArgsArray An array of arguments to a Bijection function. Bijection functions can take either a single DefaultFunctionArgs object or no args at all.

ArgsArrayToObject

Ƭ ArgsArrayToObject<Args>: Args extends OneArgArray<infer ArgsObject> ? ArgsObject : EmptyObject Convert an ArgsArray into a single object type. Empty arguments arrays are converted to EmptyObject.

Type parameters

Name	Type
`Args`	extends `ArgsArray`

FunctionVisibility

Ƭ FunctionVisibility: "public" | "internal" A type representing the visibility of a Bijection function.

RegisteredMutation

Ƭ RegisteredMutation<Visibility, Args, Returns>: { isBijectionFunction: true ; isMutation: true } & VisibilityProperties<Visibility> A mutation function that is part of this app. You can create a mutation by wrapping your function in mutationGeneric or internalMutationGeneric and exporting it.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility`
`Args`	extends `DefaultFunctionArgs`
`Returns`	`Returns`

RegisteredQuery

Ƭ RegisteredQuery<Visibility, Args, Returns>: { isBijectionFunction: true ; isQuery: true } & VisibilityProperties<Visibility> A query function that is part of this app. You can create a query by wrapping your function in queryGeneric or internalQueryGeneric and exporting it.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility`
`Args`	extends `DefaultFunctionArgs`
`Returns`	`Returns`

RegisteredAction

Ƭ RegisteredAction<Visibility, Args, Returns>: { isBijectionFunction: true ; isAction: true } & VisibilityProperties<Visibility> An action that is part of this app. You can create an action by wrapping your function in actionGeneric or internalActionGeneric and exporting it.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility`
`Args`	extends `DefaultFunctionArgs`
`Returns`	`Returns`

PublicHttpAction

Ƭ PublicHttpAction: Object An HTTP action that is part of this app’s public API. You can create public HTTP actions by wrapping your function in httpActionGeneric and exporting it.

Type declaration

Name	Type
`isHttp`	`true`

UnvalidatedFunction

Ƭ UnvalidatedFunction<Ctx, Args, Returns>: (ctx: Ctx, …args: Args) => Returns | { handler: (ctx: Ctx, …args: Args) => Returns } Deprecated — See the type definition for MutationBuilder or similar for the types used for defining Bijection functions. The definition of a Bijection query, mutation, or action function without argument validation. Bijection functions always take a context object as their first argument and an (optional) args object as their second argument. This can be written as a function like:

import { query } from "./_generated/server";

export const func = query(({ db }, { arg }) => {...});

or as an object like:

import { query } from "./_generated/server";

export const func = query({
  handler: ({ db }, { arg }) => {...},
});

See ValidatedFunction to add argument validation.

Type parameters

Name	Type
`Ctx`	`Ctx`
`Args`	extends `ArgsArray`
`Returns`	`Returns`

ReturnValueForOptionalValidator

Ƭ ReturnValueForOptionalValidator<ReturnsValidator>: [ReturnsValidator] extends [Validator<any, any, any>] ? ValidatorTypeToReturnType<Infer<ReturnsValidator>> : [ReturnsValidator] extends [PropertyValidators] ? ValidatorTypeToReturnType<ObjectType<ReturnsValidator>> : any There are multiple syntaxes for defining a Bijection function:

 - query(async (ctx, args) => {...})
 - query({ handler: async (ctx, args) => {...} })
 - query({ args: { a: v.string }, handler: async (ctx, args) => {...} } })
 - query({ args: { a: v.string }, returns: v.string(), handler: async (ctx, args) => {...} } })

In each of these, we want to correctly infer the type for the arguments and return value, preferring the type derived from a validator if it’s provided. To avoid having a separate overload for each, which would show up in error messages, we use the type params — ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs. The type for ReturnValue and OneOrZeroArgs are constrained by the type or ArgsValidator and ReturnsValidator if they’re present, and inferred from any explicit type annotations to the arguments or return value of the function. Below are a few utility types to get the appropriate type constraints based on an optional validator. Additional tricks:

We use Validator | void instead of Validator | undefined because the latter does not work with strictNullChecks since it’s equivalent to just Validator.
We use a tuple type of length 1 to avoid distribution over the union https://github.com/microsoft/TypeScript/issues/29368#issuecomment-453529532

Type parameters

Name	Type
`ReturnsValidator`	extends `Validator`<`any`, `any`, `any`> \| `PropertyValidators` \| `void`

ArgsArrayForOptionalValidator

Ƭ ArgsArrayForOptionalValidator<ArgsValidator>: [ArgsValidator] extends [Validator<any, any, any>] ? OneArgArray<Infer<ArgsValidator>> : [ArgsValidator] extends [PropertyValidators] ? OneArgArray<ObjectType<ArgsValidator>> : ArgsArray

Type parameters

Name	Type
`ArgsValidator`	extends `GenericValidator` \| `PropertyValidators` \| `void`

DefaultArgsForOptionalValidator

Ƭ DefaultArgsForOptionalValidator<ArgsValidator>: [ArgsValidator] extends [Validator<any, any, any>] ? [Infer<ArgsValidator>] : [ArgsValidator] extends [PropertyValidators] ? [ObjectType<ArgsValidator>] : OneArgArray

Type parameters

Name	Type
`ArgsValidator`	extends `GenericValidator` \| `PropertyValidators` \| `void`

MutationBuilder

Ƭ MutationBuilder<DataModel, Visibility>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation: { args?: ArgsValidator ; returns?: ReturnsValidator ; handler: (ctx: GenericMutationCtx<DataModel>, …args: OneOrZeroArgs) => ReturnValue } | (ctx: GenericMutationCtx<DataModel>, …args: OneOrZeroArgs) => ReturnValue) => RegisteredMutation<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Visibility`	extends `FunctionVisibility`

Type declaration

▸ <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation): RegisteredMutation<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Internal type helper used by Bijection code generation. Used to give mutationGeneric a type specific to your data model.

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`mutation`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericMutationCtx`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericMutationCtx`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredMutation<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

MutationBuilderWithTable

Ƭ MutationBuilderWithTable<DataModel, Visibility>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation: { args?: ArgsValidator ; returns?: ReturnsValidator ; handler: (ctx: GenericMutationCtxWithTable<DataModel>, …args: OneOrZeroArgs) => ReturnValue } | (ctx: GenericMutationCtxWithTable<DataModel>, …args: OneOrZeroArgs) => ReturnValue) => RegisteredMutation<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Visibility`	extends `FunctionVisibility`

Type declaration

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`mutation`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericMutationCtxWithTable`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericMutationCtxWithTable`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredMutation<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

QueryBuilder

Ƭ QueryBuilder<DataModel, Visibility>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query: { args?: ArgsValidator ; returns?: ReturnsValidator ; handler: (ctx: GenericQueryCtx<DataModel>, …args: OneOrZeroArgs) => ReturnValue } | (ctx: GenericQueryCtx<DataModel>, …args: OneOrZeroArgs) => ReturnValue) => RegisteredQuery<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Visibility`	extends `FunctionVisibility`

Type declaration

▸ <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query): RegisteredQuery<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Internal type helper used by Bijection code generation. Used to give queryGeneric a type specific to your data model.

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`query`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericQueryCtx`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericQueryCtx`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredQuery<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

QueryBuilderWithTable

Ƭ QueryBuilderWithTable<DataModel, Visibility>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query: { args?: ArgsValidator ; returns?: ReturnsValidator ; handler: (ctx: GenericQueryCtxWithTable<DataModel>, …args: OneOrZeroArgs) => ReturnValue } | (ctx: GenericQueryCtxWithTable<DataModel>, …args: OneOrZeroArgs) => ReturnValue) => RegisteredQuery<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Visibility`	extends `FunctionVisibility`

Type declaration

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`query`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericQueryCtxWithTable`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericQueryCtxWithTable`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredQuery<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

ActionBuilder

Ƭ ActionBuilder<DataModel, Visibility>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(func: { args?: ArgsValidator ; capabilities?: { functions: readonly FunctionReference<"query" | "mutation" | "action", "public" | "internal">[] } ; returns?: ReturnsValidator ; handler: (ctx: GenericActionCtx<DataModel>, …args: OneOrZeroArgs) => ReturnValue } | (ctx: GenericActionCtx<DataModel>, …args: OneOrZeroArgs) => ReturnValue) => RegisteredAction<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Visibility`	extends `FunctionVisibility`

Type declaration

▸ <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(func): RegisteredAction<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Internal type helper used by Bijection code generation. Used to give actionGeneric a type specific to your data model.

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`func`	{ `args?`: `ArgsValidator` ; `capabilities?`: { `functions`: readonly `FunctionReference`<`"query"` \| `"mutation"` \| `"action"`, `"public"` \| `"internal"`>[] } ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericActionCtx`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericActionCtx`<`DataModel`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredAction<Visibility, ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

HttpActionBuilder

Ƭ HttpActionBuilder: (func: (ctx: GenericActionCtx<any>, request: Request) => Promise<Response>) => PublicHttpAction

Type declaration

▸ (func): PublicHttpAction Internal type helper used by Bijection code generation. Used to give httpActionGeneric a type specific to your data model and functions.

Parameters

Name	Type
`func`	(`ctx`: `GenericActionCtx`<`any`>, `request`: `Request`) => `Promise`<`Response`>

Returns

PublicHttpAction

RoutableMethod

Ƭ RoutableMethod: typeof ROUTABLE_HTTP_METHODS[number] A type representing the methods supported by Bijection HTTP actions. HEAD is handled by Bijection by running GET and stripping the body. CONNECT is not supported and will not be supported. TRACE is not supported and will not be supported.

RouteSpecWithPath

Ƭ RouteSpecWithPath: Object A type representing a route to an HTTP action using an exact request URL path match. Used by HttpRouter to route requests to HTTP actions.

Type declaration

Name	Type	Description
`path`	`string`	Exact HTTP request path to route.
`method`	`RoutableMethod`	HTTP method (“GET”, “POST”, …) to route.
`handler`	`PublicHttpAction`	The HTTP action to execute.

RouteSpecWithPathPrefix

Ƭ RouteSpecWithPathPrefix: Object A type representing a route to an HTTP action using a request URL path prefix match. Used by HttpRouter to route requests to HTTP actions.

Type declaration

Name	Type	Description
`pathPrefix`	`string`	An HTTP request path prefix to route. Requests with a path starting with this value will be routed to the HTTP action.
`method`	`RoutableMethod`	HTTP method (“GET”, “POST”, …) to route.
`handler`	`PublicHttpAction`	The HTTP action to execute.

RouteSpec

Ƭ RouteSpec: RouteSpecWithPath | RouteSpecWithPathPrefix A type representing a route to an HTTP action. Used by HttpRouter to route requests to HTTP actions.

SchedulableFunctionReference

Ƭ SchedulableFunctionReference: FunctionReference<"mutation" | "action", "public" | "internal"> A FunctionReference that can be scheduled to run in the future. Schedulable functions are mutations and actions that are public or internal.

SystemFieldValidators

Ƭ SystemFieldValidators<TableName>: Object The validators for the system fields Bijection adds to every document.

Type parameters

Name	Type
`TableName`	extends `string`

Type declaration

Name	Type
`_id`	`VId`<`GenericId`<`TableName`>>
`_creationTime`	`VFloat64`<`number`>

DocValidator

Ƭ DocValidator<TableName, DocumentType>: DocumentType extends VUnion<any, infer Members, any, any> ? { [Index in keyof Members]: WithSystemFieldValidators<TableName, Members[Index]> } extends infer NewMembers ? VUnion<WithSystemFieldValidators<TableName, Members[number]>["type"], NewMembers> : never : WithSystemFieldValidators<TableName, DocumentType> The validator for whole documents of a table: the table’s own validator with the _id and _creationTime system fields added. For a table defined with a union, the system fields are added to each member of the union.

Type parameters

Name	Type
`TableName`	extends `string`
`DocumentType`	extends `Validator`<`any`, `any`, `any`>

GenericSchema

Ƭ GenericSchema: Record<string, TableDefinition<any, any, any, any, boolean>> A type describing the schema of a Bijection project. This should be constructed using defineSchema, defineTable, and v.

DataModelFromSchemaDefinition

Ƭ DataModelFromSchemaDefinition<SchemaDef>: MaybeMakeLooseDataModel<{ [TableName in keyof SchemaDef[“tables”] & string]: SchemaDef[“tables”][TableName] extends ViewDefinition<infer From, infer Plan, infer ViewIndexes> ? ViewDataModelEntry<SchemaDef[“tables”], From, Plan, ViewIndexes> : SchemaDef[“tables”][TableName] extends PublishedDefinition<infer Row, infer PublishedIndexes> ? PublishedDataModelEntry<Expand<IdField<TableName> & ExtractDocument<Row>>, keyof IdField<TableName> | ExtractFieldPaths<Row>, PublishedIndexes> : SchemaDef[“tables”][TableName] extends TableDefinition<infer DocumentType, infer Indexes, infer SearchIndexes, infer VectorIndexes, infer IsSource> ? Object & SourceWritability<IsSource> : never }, SchemaDef["strictTableNameTypes"]> Internal type used in Bijection code generation! Convert a SchemaDefinition into a GenericDataModel.

Type parameters

Name	Type
`SchemaDef`	extends `SchemaDefinition`<`any`, `boolean`>

SystemTableNames

Ƭ SystemTableNames: TableNamesInDataModel<SystemDataModel>

GoverningResult

Ƭ GoverningResult: null | { validUntil: number } The result a rule gives ONE item it decides: a read or disclosure request, a table change or a command. A rule never returns it bare: it returns one per item, in order (ReadAccessResults), so a rule that falls off its end (return;, which reaches the engine as null) or returns early refuses instead of permitting what it never decided. Null permits the item with no clock-dependent expiry. A rule observing time must return its complete validity bound unless native enforcement independently establishes that bound. validUntil is finite safe-integer epoch milliseconds, strictly after the evaluation clock and at most 366 days ahead. The native committer must commit strictly before it. Throw to deny.

ReadAccess

Ƭ ReadAccess: Object Read authorization using an ordinary same-component query. The query receives the native batch described by readAccessArgs and returns one result per request (ReadAccessResults); a decision about the whole relation is written requests.map(() => decision). It runs as the original caller. Declared policy inputs are private to native policy execution, not disclosure grants. In a query, an index range withholds the rows the rule refuses and answers as if they did not exist; every other refused read, and every refused read in a mutation, refuses the whole answer. Refusal never redacts properties.

Type declaration

Name	Type	Description
`read`	`FunctionReference`<`"query"`, `"public"` \| `"internal"`, `ReadAccessArgs`, `ReadAccessResults`>	-
`disclose?`	`FunctionReference`<`"query"`, `"public"` \| `"internal"`, `DisclosureArgs`, `ReadAccessResults`>	Independently authorizes a fixed release to another destination. Omission refuses protected writes and HTTP disclosure. Uses the same private inputs; ordinary table releases are checked against pre-change authority.
`reads`	readonly `string`[]	-
`rowsFollowRange?`	readonly { `index`: `string` ; `field`: `string` ; `markings?`: `string` }[]	The ranges whose decision decides every row they deliver: a range read through `index` with `field` pinned by an equality. The author’s statement that no row of such a range narrows what the range permits. A result that would exceed the read evidence bound then keeps one covering demand per such range instead of one per row. Releases that must recheck each row’s content refuse such a result, so it is read again. A text or vector search whose filter pins `field` runs over that range’s rows alone, ranked from them, and presents the range’s demand; a text search also presents a covering demand standing for the rows it ranked among (one per marking set with `markings`). `index` must be an index of the table led by `field`. The access model reports the ranges of its types that qualify. A covering demand reaches `read` and `disclose` with `target.covers: true`. Tests and development builds check the statement: when either rule permits such a demand, every row it covers is decided too by that rule (with the same destination), and a row refused (or permitted for less time) fails the function with `RowsFollowRangeViolated`. A release build trusts it unless `BIJECTION_CHECK_DECLARED_RANGES` is set.
`audit?`	`boolean`	Record every decision of this table’s rules in the deployment’s audit log: each read `read` decides (`access.read.`), each release `disclose` decides (`access.disclose.`) and each change the table’s `.govern` rule decides (`access.write.*`). A line names the caller, the rule, what it decided — the requests, the destination’s kind and table, or each change’s id, operation and changed field names, never a value — whether it permitted, and the reason the rule gave. A refused decision’s lines name no row and no value. The engine writes the record, so nothing the function does can skip it. This is the table’s one audit declaration: a table whose writes should be audited declares `.access` with `audit`, since `.govern` has no flag of its own.
`appliesDelegation?`	`boolean`	The author’s statement that `read` applies a delegated caller’s narrowing claims (`delegatedScope`, `delegatedPermissions`), as the access model’s rules do. The engine never reads those claims: a caller carrying one is refused on every table whose read rule does not declare this, including a table without a rule.

TableChange

Ƭ TableChange<Document>: Object One net local document change passed to a table’s final governing query. Documents include their ordinary system fields. Null denotes absence.

Type parameters

Name	Type
`Document`	extends `Object`

Type declaration

Name	Type
`id`	`Document`[`"_id"`]
`before`	`Document` \| `null`
`after`	`Document` \| `null`

LinkEndpointFields

Ƭ LinkEndpointFields<DocumentType>: DocumentType extends { fields: infer Fields } ? { [Field in keyof Fields]: Fields[Field] extends Object ? Field : never }[keyof Fields] & string : never Required ID fields in a table validator eligible as relationship endpoints.

Type parameters

Name
`DocumentType`

DocumentFields

Ƭ DocumentFields<Document>: Document extends unknown ? keyof Document & string : never Top-level properties available in any variant of a document.

Type parameters

Name
`Document`

SelectedDocument

Ƭ SelectedDocument<Document, Fields>: Document extends unknown ? Pick<Document, Extract<Fields | "_id" | "_creationTime", keyof Document>> : never Selected document properties, retaining identity and creation time.

Type parameters

Name	Type
`Document`	`Document`
`Fields`	extends `string`

StorageId

Ƭ StorageId: string Deprecated This ID format is no longer returned by stable file storage APIs. Use Id<"_storage"> instead. The old ID format used by Bijection file storage. ⚠️ Security warning: Anyone that has knows to this ID can download the underlying file from https://<deployment>.bijection.cloud/api/storage/<storageId>. (Note that it’s safe to share the new ID format, Id<"_storage">, to anyone).

FileStorageId

Ƭ FileStorageId: GenericId<"_storage"> | StorageId Deprecated This type is only necessary for backwards compatibility with Bijection versions that pre-date bijection@1.6.0. Use Id<"_storage"> instead.

FileMetadata

Ƭ FileMetadata: Object Deprecated This type is only returned by storage.getUrl. To get the details of a document, use ctx.db.system.get("_storage", storageId) instead. Metadata for a single file as returned by storage.getMetadata.

Type declaration

Name	Type	Description
`storageId`	`StorageId`	ID for referencing the file (eg. via storage.getUrl) This is an older ID format that is no longer returned by stable file storage APIs. Consider using `Id<"_storage">` instead. ⚠️ Security warning: Anyone that has knows to this ID can download the underlying file from `https://<deployment>.bijection.cloud/api/storage/<storageId>`. (Note that it’s safe to share the new ID format, `Id<"_storage">`, to anyone).
`sha256`	`string`	Hex encoded sha256 checksum of file contents
`size`	`number`	Size of the file in bytes
`contentType`	`string` \| `null`	ContentType of the file if it was provided on upload

SystemFields

Ƭ SystemFields: Object The fields that Bijection automatically adds to documents, not including _id. This is an object type mapping field name to field type.

Type declaration

Name	Type
`_creationTime`	`number`

IdField

Ƭ IdField<TableName>: Object The _id field that Bijection automatically adds to documents.

Type parameters

Name	Type
`TableName`	extends `string`

Type declaration

Name	Type
`_id`	`GenericId`<`TableName`>

WithoutSystemFields

Ƭ WithoutSystemFields<Document>: Expand<BetterOmit<Document, keyof SystemFields | "_id">> A Bijection document with the system fields like _id and _creationTime omitted.

Type parameters

Name	Type
`Document`	extends `GenericDocument`

WithOptionalSystemFields

Ƭ WithOptionalSystemFields<Document>: Expand<WithoutSystemFields<Document> & Partial<Pick<Document, keyof SystemFields | "_id">>> A Bijection document with the system fields like _id and _creationTime optional.

Type parameters

Name	Type
`Document`	extends `GenericDocument`

SystemIndexes

Ƭ SystemIndexes: Object The indexes that Bijection automatically adds to every table. This is an object mapping index names to index field paths.

Type declaration

Name	Type
`by_id`	[`"_id"`]
`by_creation_time`	[`"_creationTime"`]

IndexTiebreakerField

Ƭ IndexTiebreakerField: "_creationTime" Bijection automatically appends “_creationTime” to the end of every index to break ties if all of the other fields are identical.

VectorSearch

Ƭ VectorSearch<DataModel, TableName, IndexName>: (tableName: TableName, indexName: IndexName, query: VectorSearchQuery<NamedTableInfo<DataModel, TableName>, IndexName>) => Promise<{ _id: GenericId<TableName> ; _score: number }[]>

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`TableName`	extends `TableNamesInDataModel`<`DataModel`>
`IndexName`	extends `VectorIndexNames`<`NamedTableInfo`<`DataModel`, `TableName`>>

Type declaration

▸ (tableName, indexName, query): Promise<{ _id: GenericId<TableName> ; _score: number }[]>

Parameters

Name	Type
`tableName`	`TableName`
`indexName`	`IndexName`
`query`	`VectorSearchQuery`<`NamedTableInfo`<`DataModel`, `TableName`>, `IndexName`>

Returns

Promise<{ _id: GenericId<TableName> ; _score: number }[]>

ViewLimits

Ƭ ViewLimits: Object The bounded work requested by a view. Deployment also enforces server caps.

Type declaration

Name	Type
`max_rows`	`number`
`max_bytes`	`number`

ViewKey

Ƭ ViewKey<From>: Object

Type parameters

Name	Type
`From`	extends `string` = `string`

Type declaration

Name	Type
`from`	`From`
`field`	`"_id"`

ViewWindow

Ƭ ViewWindow: Object Rolling latest-N rows within each group at the pinned read basis. Values sort ascending by these fields, then the complete row; the greatest rows enter the frame. Strings sort lexically. This does not expire by wall time.

Type declaration

Name	Type
`order_by`	readonly `string`[]
`rows`	`number`

ViewPlan

Ƭ ViewPlan: { kind: "scan" ; table: string } | { kind: "alias" ; input: ViewPlan ; alias: string } | { kind: "filter" ; input: ViewPlan ; predicate: JSONValue } | { kind: "select" ; input: ViewPlan ; fields: Record<string, JSONValue> } | { kind: "join" ; input: ViewPlan ; right: ViewPlan ; join: "left" | "inner" ; left: string[] ; right_field: string[] ; index?: string ; cardinality: "one" | "many" } | { kind: "group" ; input: ViewPlan ; fields: string[] ; aggregates: Record<string, ViewAggregate> ; window?: ViewWindow } Canonical relational declaration; scalar expressions use the ordinary query wire format.

SerializedView

Ƭ SerializedView: Object

Type declaration

Name	Type
`version`	`1`
`mode`	`"virtual"` \| `"materialized"`
`key`	`ViewKey`
`expression`	`ViewPlan`
`limits`	`ViewLimits`

ViewJoinOptions

Ƭ ViewJoinOptions: Object

Type declaration

Name	Type	Description
`left`	`string` \| readonly `string`[]	Equalities in index order. Both sides must name the complete grouped key.
`right`	`string` \| readonly `string`[]	-
`index?`	`string`	Required for a base-table join except its built-in ID index. Group inputs use their group key.
`cardinality?`	`"one"` \| `"many"`	-

BarrierInstant

Ƭ BarrierInstant: Object The instant a common barrier requires every named source to have reached. There is deliberately no literal-revision form here. An engine revision does not fit a JavaScript number exactly, and a barrier written against a rounded revision would compare against an instant nobody chose. A decision that needs a literal revision states it where revisions are exact; from TypeScript, a barrier is anchored on a source’s own publication.

Type declaration

Name	Type
`kind`	`"publication_of"`
`of`	`SourceScope`

SourceScope

Ƭ SourceScope: Object One installed source and the scope of it a decision reads. A barrier names a source the way the rest of the engine does; it introduces no new identity.

Type declaration

Name	Type
`source`	`string`
`scope`	`string`

SourceBarrier

Ƭ SourceBarrier: { kind: "none" } | { kind: "each_latest" } | { kind: "complete_versions" } | { kind: "common" ; at: BarrierInstant } The barrier a decision declares over the source-bound relations it reads.

WaitDefinition

Ƭ WaitDefinition: Object A durable wait a business program declares. A business-time boundary — a price validity lapsing, a supplier’s ship-by promise falling due, a temporary override ending — changes nothing about the rows it is about when it passes. Something has to commit. Until now the only way a program could say so was a cron sweeping on an interval, which makes the interval the deadline’s precision and runs whether or not anything is due. A declaration names two of the deployment’s own internal functions and nothing else:

due, a query answering when this concern’s next boundary is, as epoch milliseconds, or null when there is none. It is read through the ordinary reader, so the rows it reads become the wait’s region set: a committed write that moves the answer is what re-arms the wait, and between boundaries nothing runs.
then, a mutation the engine schedules through the ordinary scheduler in the transaction that settles the wait.

Both names are resolved against the deployment at push — a declaration naming a function the deployment does not declare is refused there — and then is resolved AGAIN in the transaction that releases the work, because a wait row outlives the push that created it and the deployment current when the boundary arrives is the one whose authority the release runs under. Both are internal, which is the program saying these entry points belong to the engine rather than to any client that can reach the deployment. A declaration may also name keys, an internal query returning at most 32 stable instance keys (strings of 1 to 128 bytes). Each key is then its own standing wait: its due runs in its own transaction, so one instance’s reads never become another’s, and due and then receive { key }. A key the query stops listing is retired. keys should read only routing that grants nothing by itself; then still rechecks the instance’s own state, because a key can be removed between the boundary and the continuation.

export const priceValidity = defineWait({
  due: internal.catalogue.nextPriceExpiry,
  then: internal.catalogue.expirePrices,
});

Type declaration

Name	Type
`isWait`	`true`

Expand

Ƭ Expand<ObjectType>: ObjectType extends Record<any, any> ? { [Key in keyof ObjectType]: ObjectType[Key] } : never Hack! This type causes TypeScript to simplify how it renders object types. It is functionally the identity for object types, but in practice it can simplify expressions like A & B.

Type parameters

Name	Type
`ObjectType`	extends `Record`<`any`, `any`>

BetterOmit

Ƭ BetterOmit<T, K>: { [Property in keyof T as Property extends K ? never : Property]: T[Property] } An Omit<> type that:

Applies to each element of a union.
Preserves the index signature of the underlying type.

Type parameters

Name	Type
`T`	`T`
`K`	extends keyof `T`

Variables

anyApi

• Const anyApi: AnyApi A utility for constructing FunctionReferences in projects that are not using code generation. You can create a reference to a function like:

const reference = anyApi.myModule.myFunction;

This supports accessing any path regardless of what directories and modules are in your project. All function references are typed as AnyFunctionReference. If you’re using code generation, use api from bijection/_generated/api instead. It will be more type-safe and produce better auto-complete in your editor.

execution

• Const execution: Object

Type declaration

Name	Type
`acquireSnapshot`	(`key`: `string`, `handle`: `string`) => `Promise`<`string`>
`useSnapshot`	(`lease`: `string`) => `Promise`<`null`>
`releaseSnapshot`	(`lease`: `string`) => `Promise`<`null`>
`limitTransaction`	(`limits`: `TransactionLimits`) => `Promise`<`null`>
`begin`	() => `Promise`<{ `code`: `string` ; `name`: `string` ; `resources`: `ExecutionResources` }>
`basis`	(`handle`: `string`) => `Promise`<{ `code`: `string` ; `name`: `string` }>
`seal`	(`payload`: `string`) => `Promise`<`string`>
`sealCaptured`	(`payload`: `string`) => `Promise`<`string`>
`open`	(`token`: `string`, `payload`: `string`) => `Promise`<{ `code`: `string` ; `name`: `string` ; `scheduled`: `string` ; `digest`: `string` ; `verifiedCapturesDigest?`: `string` ; `verifiedCapturesComplete?`: `boolean` ; `resources`: `ExecutionResources` }>

ROOT_TYPE

• Const ROOT_TYPE: "root" The one object every tree hangs from. A type without a parent is a child of the root, so an administrator of everything is an ordinary role on an ordinary object, and a whole-table read is a scope pinned at the root.

ROOT_KEY

• Const ROOT_KEY: "*" The key of the single root object.

log

• Const log: Log

paginationOptsValidator

• Const paginationOptsValidator: VObject<{ id: undefined | number ; endCursor: undefined | null | string ; maximumRowsRead: undefined | number ; maximumBytesRead: undefined | number ; numItems: number ; cursor: null | string }, { numItems: VFloat64<number, "required"> ; cursor: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; endCursor: VUnion<undefined | null | string, [VString<string, "required">, VNull<null, "required">], "optional", never> ; id: VFloat64<undefined | number, "optional"> ; maximumRowsRead: VFloat64<undefined | number, "optional"> ; maximumBytesRead: VFloat64<undefined | number, "optional"> }, "required", "id" | "numItems" | "cursor" | "endCursor" | "maximumRowsRead" | "maximumBytesRead"> A Validator for PaginationOptions. Use this as the args validator in paginated query functions so that clients can pass pagination options. Example

import { query } from "./_generated/server";
import { paginationOptsValidator } from "bijection/server";
import { v } from "bijection/values";

export const listMessages = query({
  args: {
    channelId: v.id("channels"),
    paginationOpts: paginationOptsValidator,
  },
  handler: async (ctx, args) => {
    return await ctx.db
      .query("messages")
      .withIndex("by_channel", (q) => q.eq("channelId", args.channelId))
      .order("desc")
      .paginate(args.paginationOpts);
  },
});

On the client, use usePaginatedQuery from "bijection/react":

const { results, status, loadMore } = usePaginatedQuery(
  api.messages.listMessages,
  { channelId },
  { initialNumItems: 25 },
);

See https://docs.bijection.com/database/pagination

publications

• Const publications: Object

Type declaration

Name	Type
`consuming`	<T>(`fn`: `T`, `declaration`: `PublicationConsumption`) => `T`
`isCurrentTransition`	(`input`: { `publisher`: `string` ; `producer`: `string` ; `tables`: `string`[] ; `epoch`: `string` ; `transitionId`: `string` }) => `Promise`<`boolean`>
`require`	(`requirement`: `PublicationRequirement`) => `Promise`<`null`>
`readiness`	(`requirement`: `PublicationRequirement`) => `Promise`<`PublicationReadiness`>
`checkpoint`	(`input`: { `table`: `string` ; `source?`: `string` }) => `Promise`<`string`>
`acceptedCheckpoint`	(`input`: { `operation`: `string` ; `invocation_id`: `string` ; `table`: `string` }) => `Promise`<`string`>
`capture`	(`input`: { `table`: `string` ; `source?`: { `id`: `string` ; `index`: `string` } ; `publication?`: `PublicationSelection` ; `partitionField?`: `string` ; `cursor`: `null` \| `string` ; `limit`: `number` }) => `Promise`<`PublicationCapture`>
`partitionPlan`	(`input`: { `pages`: `string`[] ; `partitionField`: `string` }) => `Promise`<`string`>
`authorizeMemberRead`	(`input`: { `table`: `string` ; `producer`: `string` ; `member`: `string` }) => `Promise`<`null`>
`requirePublisherQuery`	(`role`: `"page"` \| `"manifest"` \| `"steps"`, `owner?`: { `publisher`: { `manifest`: `string` ; `steps`: `string` ; `page`: `string` } ; `run?`: `string` ; `selection?`: `string` ; `member?`: `string` }) => `Promise`<`null`>
`status`	(`table`: `string`, `selection`: `null` \| `string`) => `Promise`<`PublicationStatus`>

readAccessArgs

• Const readAccessArgs: Object Arguments for an ordinary query used by .access({ read, reads }). The native reader constructs the complete batch. Calling the query directly does not grant private policy-input access or authorize another database read. properties: null requires the whole document. Otherwise properties include selected fields and fields contributing to membership, filtering and order, including _id and _creationTime. Nested paths require their whole top-level property. Query equalities are guaranteed index bounds, not guessed filters. An omitted equality value denotes absence; null remains an explicit value. A query target with covers: true stands for rows the engine does not present as requests of their own: a maintained total, a count, a table change token, a whole relation’s status, a range folded past the read evidence bound (rowsFollowRange) or a retained obligation kept in place of per-row requests. Its result decides every row it covers. Without the key, any row the read returned arrives as a request of its own.

Type declaration

Name	Type
`requests`	`VArray`<{ `table`: `string` ; `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; kind: “query”; equalities: { value?: Value; field: string; }[]; } }[], `VObject`<{ `table`: `string` ; `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; kind: “query”; equalities: { value?: Value; field: string; }[]; } }, { `table`: `VString`<`string`, `"required"`> ; `properties`: `VUnion`<`null` \| `string`[], [`VNull`<`null`, `"required"`>, `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>], `"required"`, `never`> ; `target`: `VUnion`<{ `kind`: `"object"` ; `id`: `string` } \| { `covers`: `undefined` \| `true` ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, [`VObject`<{ `kind`: `"object"` ; `id`: `string` }, { `kind`: `VLiteral`<`"object"`, `"required"`> ; `id`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"id"`>, `VObject`<{ `covers`: `undefined` \| `true` ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, { `kind`: `VLiteral`<`"query"`, `"required"`> ; `equalities`: `VArray`<{ `value`: `undefined` \| `Value` ; `field`: `string` }[], `VObject`<{ `value`: `undefined` \| `Value` ; `field`: `string` }, { `field`: `VString`<`string`, `"required"`> ; `value`: `VAny`<`undefined` \| `Value`, `"optional"`, `string`> }, `"required"`, `"value"` \| `"field"` \| `value.${string}`>, `"required"`> ; `covers`: `VLiteral`<`undefined` \| `true`, `"optional"`> }, `"required"`, `"kind"` \| `"equalities"` \| `"covers"`>], `"required"`, `"kind"` \| `"id"` \| `"equalities"` \| `"covers"`> }, `"required"`, `"table"` \| `"properties"` \| `"target"` \| `"target.kind"` \| `"target.id"` \| `"target.equalities"` \| `"target.covers"`>, `"required"`>

readAccessResults

• Const readAccessResults: VArray<(null | { reason: undefined | string ; validUntil: number } | { reason: string })[], VUnion<null | { reason: undefined | string ; validUntil: number } | { reason: string }, [VNull<null, "required">, VObject<{ reason: undefined | string ; validUntil: number }, { validUntil: VFloat64<number, "required"> ; reason: VString<undefined | string, "optional"> }, "required", "validUntil" | "reason">, VObject<{ reason: string }, { reason: VString<string, "required"> }, "required", "reason">], "required", "validUntil" | "reason">, "required"> The return validator of every rule: read, disclose, a table’s write rule (.govern) and an integration command’s rule. A command rule gives no reason; one that defers with recheckAt declares that member beside null and { validUntil }.

disclosureArgs

• Const disclosureArgs: Object Arguments for the source’s optional .access({ disclose }) query. The host supplies actual information dependencies and the exact fixed destination. A table release gives the resulting record its destination table’s policy; it does not grant future reads of the source or retract previously released bytes when a source grant is later revoked.

Type declaration

Name	Type
`requests`	`VArray`<{ `table`: `string` ; `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; kind: “query”; equalities: { value?: Value; field: string; }[]; } }[], `VObject`<{ `table`: `string` ; `properties`: `null` \| `string`[] ; `target`: { kind: “object”; id: string; } \| { covers?: true; kind: “query”; equalities: { value?: Value; field: string; }[]; } }, { `table`: `VString`<`string`, `"required"`> ; `properties`: `VUnion`<`null` \| `string`[], [`VNull`<`null`, `"required"`>, `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`>], `"required"`, `never`> ; `target`: `VUnion`<{ `kind`: `"object"` ; `id`: `string` } \| { `covers`: `undefined` \| `true` ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, [`VObject`<{ `kind`: `"object"` ; `id`: `string` }, { `kind`: `VLiteral`<`"object"`, `"required"`> ; `id`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"id"`>, `VObject`<{ `covers`: `undefined` \| `true` ; `kind`: `"query"` ; `equalities`: { value?: Value; field: string; }[] }, { `kind`: `VLiteral`<`"query"`, `"required"`> ; `equalities`: `VArray`<{ `value`: `undefined` \| `Value` ; `field`: `string` }[], `VObject`<{ `value`: `undefined` \| `Value` ; `field`: `string` }, { `field`: `VString`<`string`, `"required"`> ; `value`: `VAny`<`undefined` \| `Value`, `"optional"`, `string`> }, `"required"`, `"value"` \| `"field"` \| `value.${string}`>, `"required"`> ; `covers`: `VLiteral`<`undefined` \| `true`, `"optional"`> }, `"required"`, `"kind"` \| `"equalities"` \| `"covers"`>], `"required"`, `"kind"` \| `"id"` \| `"equalities"` \| `"covers"`> }, `"required"`, `"table"` \| `"properties"` \| `"target"` \| `"target.kind"` \| `"target.id"` \| `"target.equalities"` \| `"target.covers"`>, `"required"`>
`destination`	`VUnion`<{ `kind`: `"table"` ; `changes`: { id: string; before: any; after: any; }[] ; `table`: `string` ; `component`: `null` \| `string` } \| { `kind`: `"http"` ; `url`: `string` ; `method`: `string` } \| { `kind`: `"command"` ; `target`: `string` ; `component`: `null` \| `string` ; `command`: `string` ; `integration`: `string` ; `contract`: `string` ; `phase`: `"acceptance"` \| `"send"` \| `"reconcile"` ; `args`: `any` } \| { `kind`: `"storageShare"` ; `storageId`: `string` ; `shareId`: `string` ; `sha256`: `string` ; `size`: `number` ; `recipient`: `string` ; `expiresAt`: `number` } \| { `kind`: `"storageRevoke"` ; `storageId`: `string` ; `shareId`: `string` ; `recipient`: `string` } \| { `kind`: `"custody"` ; `component`: `null` \| `string` }, [`VObject`<{ `kind`: `"table"` ; `changes`: { id: string; before: any; after: any; }[] ; `table`: `string` ; `component`: `null` \| `string` }, { `kind`: `VLiteral`<`"table"`, `"required"`> ; `component`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `table`: `VString`<`string`, `"required"`> ; `changes`: `VArray`<{ `id`: `string` ; `before`: `any` ; `after`: `any` }[], `VObject`<{ `id`: `string` ; `before`: `any` ; `after`: `any` }, { `id`: `VString`<`string`, `"required"`> ; `before`: `VUnion`<`any`, [`VNull`<`null`, `"required"`>, `VAny`<`any`, `"required"`, `string`>], `"required"`, `string`> ; `after`: `VUnion`<`any`, [`VNull`<`null`, `"required"`>, `VAny`<`any`, `"required"`, `string`>], `"required"`, `string`> }, `"required"`, `"id"` \| `"before"` \| `"after"` \| `before. $\{string}\` \\| \`after.$ {string}`>, `"required"`> }, `"required"`, `"kind"` \| `"changes"` \| `"table"` \| `"component"`>, `VObject`<{ `kind`: `"http"` ; `url`: `string` ; `method`: `string` }, { `kind`: `VLiteral`<`"http"`, `"required"`> ; `url`: `VString`<`string`, `"required"`> ; `method`: `VString`<`string`, `"required"`> }, `"required"`, `"kind"` \| `"url"` \| `"method"`>, `VObject`<{ `kind`: `"command"` ; `target`: `string` ; `component`: `null` \| `string` ; `command`: `string` ; `integration`: `string` ; `contract`: `string` ; `phase`: `"acceptance"` \| `"send"` \| `"reconcile"` ; `args`: `any` }, { `kind`: `VLiteral`<`"command"`, `"required"`> ; `component`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `integration`: `VString`<`string`, `"required"`> ; `command`: `VString`<`string`, `"required"`> ; `target`: `VString`<`string`, `"required"`> ; `contract`: `VString`<`string`, `"required"`> ; `phase`: `VUnion`<`"acceptance"` \| `"send"` \| `"reconcile"`, [`VLiteral`<`"acceptance"`, `"required"`>, `VLiteral`<`"send"`, `"required"`>, `VLiteral`<`"reconcile"`, `"required"`>], `"required"`, `never`> ; `args`: `VAny`<`any`, `"required"`, `string`> }, `"required"`, `"kind"` \| `"target"` \| `"component"` \| `"command"` \| `"integration"` \| `"contract"` \| `"phase"` \| `"args"` \| `args. $\{string}\`\>], ``"required"``, ``"kind"`` \\| ``"changes"`` \\| ``"table"`` \\| ``"target"`` \\| ``"component"`` \\| ``"url"`` \\| ``"method"`` \\| ``"command"`` \\| ``"integration"`` \\| ``"contract"`` \\| ``"phase"`` \\| ``"args"`` \\| \`args.$ {string}` \| `"storageId"` \| `"shareId"` \| `"sha256"` \| `"size"` \| `"recipient"` \| `"expiresAt"`>

ROUTABLE_HTTP_METHODS

• Const ROUTABLE_HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"] A list of the methods supported by Bijection HTTP actions. HEAD is handled by Bijection by running GET and stripping the body. CONNECT is not supported and will not be supported. TRACE is not supported and will not be supported.

q

• Const q: Object Declarative relational and scalar operators, evaluated by the engine.

Type declaration

Name	Type
`eq`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`boolean`>
`neq`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`boolean`>
`lt`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`boolean`>
`lte`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`boolean`>
`gt`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`boolean`>
`gte`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`boolean`>
`add`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`T`>
`sub`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`T`>
`mul`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`T`>
`div`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`T`>
`mod`	<T>(`l`: `ExpressionOrValue`<`T`>, `r`: `ExpressionOrValue`<`T`>) => `Expression`<`T`>
`neg`	<T>(`x`: `ExpressionOrValue`<`T`>) => `Expression`<`T`>
`and`	(…`exprs`: `ExpressionOrValue`<`boolean`>[]) => `Expression`<`boolean`>
`or`	(…`exprs`: `ExpressionOrValue`<`boolean`>[]) => `Expression`<`boolean`>
`not`	(`x`: `ExpressionOrValue`<`boolean`>) => `Expression`<`boolean`>
`table`	<Name>(`table`: `Name`) => `ViewQuery`<`Scan`<`Name`>>
`field`	<Path>(`path`: `Path`) => `ViewField`<`Path`>
`count`	() => { `kind`: `"count"` }
`sum`	<Field>(`field`: `Field`) => { `kind`: `"sum"` ; `field`: `Field` }
`decimalSum`	<Field>(`field`: `Field`, `scale`: `number`) => { `kind`: `"decimal_sum"` ; `field`: `Field` ; `scale`: `number` }
`countDistinct`	<Field>(`field`: `Field`) => { `kind`: `"count_distinct"` ; `field`: `Field` }
`percentile`	<Field>(`field`: `Field`, `basisPoints`: `number`) => { `kind`: `"percentile"` ; `field`: `Field` ; `basis_points`: `number` = basisPoints; `decimal_scale`: `null` = null }
`decimalPercentile`	<Field>(`field`: `Field`, `basisPoints`: `number`, `scale`: `number`) => { `kind`: `"percentile"` ; `field`: `Field` ; `basis_points`: `number` = basisPoints; `decimal_scale`: `number` = scale }

sourceBarrier

• Const sourceBarrier: Object The barriers, as declared data. The wire shape is exactly what the engine decodes; views.barrier.test.ts and the Rust decoder each pin it against independent literals.

Type declaration

Name	Type
`none`	() => `SourceBarrier`
`eachLatest`	() => `SourceBarrier`
`completeVersions`	() => `SourceBarrier`
`publishedWith`	(`source`: `string`, `scope`: `string`) => `SourceBarrier`

Functions

getFunctionName

▸ getFunctionName(functionReference): string Get the name of a function from a FunctionReference. The name is a string like “myDir/myModule:myFunction”. If the exported name of the function is "default", the function name is omitted (e.g. “myDir/myModule”).

Parameters

Name	Type	Description
`functionReference`	`FunctionReference`<`any`, `any`, `any`, `any`, `undefined` \| `string`> \| `FunctionReference_future`<`any`, `any`, `any`, `any`, `undefined` \| `string`>	A FunctionReference to get the name of.

Returns

string A string of the function’s name.

makeFunctionReference

▸ makeFunctionReference<type, args, ret>(name): FunctionReference<type, "public", args, ret> FunctionReferences generally come from generated code, but in custom clients it may be useful to be able to build one manually. Real function references are empty objects at runtime, but the same interface can be implemented with an object for tests and clients which don’t use code generation.

Type parameters

Name	Type
`type`	extends `FunctionType`
`args`	extends `DefaultFunctionArgs` = `any`
`ret`	`any`

Parameters

Name	Type	Description
`name`	`string`	The identifier of the function. E.g. `path/to/file:functionName`

Returns

FunctionReference<type, "public", args, ret>

filterApi

▸ filterApi<API, Predicate>(api): FilterApi<API, Predicate> Given an api of type API and a FunctionReference subtype, return an api object containing only the function references that match.

const q = filterApi<typeof api, FunctionReference<"query">>(api)

Type parameters

Name
`API`
`Predicate`

Parameters

Name	Type
`api`	`API`

Returns

FilterApi<API, Predicate>

getMany

▸ getMany(_ctx, table, ids): Promise<AppPointRead[]> Read several objects of one table or view by identifier, each answered on its own: object, absent, or restricted when the engine refused that object’s read for the caller. At most 100 distinct identifiers, answered in order; an identifier that is not one of this table’s is refused as db.get refuses it. In a query, one refused object answers restricted and the rest of the answer stands. Everywhere else (a mutation, a policy) these are ordinary point reads, and a refused one refuses the whole call as db.get does. Every other read of the query is still decided with the whole answer, except that a query’s index range withholds the rows the caller may not read, as if they did not exist.

Parameters

Name	Type
`_ctx`	`GenericQueryCtx`<`GenericDataModel`>
`table`	`string`
`ids`	`string`[]

Returns

Promise<AppPointRead[]>

applicationQueries

▸ applicationQueries(definition): Object

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.collections`	`Record`<`string`, `AppPresentation`>	-
`definition.operations`	`Record`<`string`, `AppPresentation`>	-
`definition.authorize`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>) => `Promise`<`void`>	Refuse (throw) unless the caller is a current member of this product. It is run for every query with the caller’s own context. It is also run to decide whether the OWNER of a shared saved view is still a member, with `ctx.auth` answering for that owner as the state row retains them (token identifier, issuer and subject only) while every other context member still acts for the reader. The callback must therefore decide from `ctx.auth` and the deployment environment alone: a database read inside it would answer for the reader, not the owner. An error the callback throws itself means “not a member” and hides the view; an error raised by an engine call it makes (a refused or over-budget read) fails the query.
`definition.features?`	`AppFeature`[]	Capabilities exposed beside collections and operations. Each entry is disclosure metadata whose module enforces its own access.
`definition.stateTable?`	`string`	Customer-owned table with the indexes by_owner_key (`["owner", "key"]`) and by_shared (`["is_shared", "key"]`); see `ApplicationStateAccess`.
`definition.people?`	`ApplicationPeople`	Who the application’s people are; see `ApplicationPeople`. Required to declare notifications: the caller’s own person is their recipient.
`definition.notifications?`	`ApplicationNotifications`	-
`definition.series?`	`ApplicationSeries`	Readers of declared geotemporal series properties, by collection and property; see `AppSeriesReader` (`@bijection/datasets/geotemporal` builds one).
`definition.places?`	`ApplicationPlaces`	Location search for maps: a durable request and its reactive answer; see `ApplicationPlaces`.
`definition.mapValues?`	`ApplicationMapValues`	Values the program computes for map styling, by name; see `ApplicationMapValues`.
`definition.spatialIndexes?`	`AppSpatialIndexes`	Spatial indexes the program answers regions, nearest objects and cell summaries with, by collection and declared geometry property; see `AppSpatialIndex` (`@bijection/datasets/appSpatial` builds one).
`definition.maps?`	`ApplicationMaps`	Deployment map settings, basemaps and who administers them; see `ApplicationMaps`.
`definition.readable?`	`Record`<`string`, (`ctx`: `GenericQueryCtx`<`GenericDataModel`>) => `Promise`<`boolean`>>	Collections the program withholds whole from a caller it does not clear, each with its decision: a collection every row of which derives from marked data, such as a marked series’ fence events. A collection declined for the caller is left out of their catalog and counted in `restricted_collections`, and every read naming it is refused: a listing, a count or a facet of it is never a short answer. It is a leaf: no other collection’s relation or connection type, the people, a notification kind or a map value names it, so nothing served refers to what is left out. A decision is the caller’s, from `ctx` (its reads are the caller’s), like `authorize`.
`definition.sourceControl?`	`ApplicationSourceControl`	Who may ask for a sync of a source, or a check of its connection (`requestSourceSync`, `requestConnectionCheck`): the caller’s decision, from `ctx`, for one source of an exposed synced collection. Absent, nobody may; reading sync history (`sourceSyncs`) needs only read access. See `ApplicationSourceControl`.

Returns

Object

Name	Type	Description
`workspaceState`	`RegisteredQuery`<`"public"`, {}, `Promise`<`AppWorkspaceState`>>	-
`saveView`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `name`: `string` ; `view`: `any` ; `revision`: `number` ; `is_shared`: `boolean` }, `Promise`<`null`>>	-
`deleteView`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `revision`: `number` }, `Promise`<`null`>>	-
`savePreferences`	`RegisteredMutation`<`"public"`, { `preferences`: { theme?: “system” \| “light” \| “dark”; density?: “compact” \| “comfortable”; locale?: string; timeZone?: string; pinnedApps?: string[]; recentObjects?: { id: string; collection: string; }[]; railGroups?: Record<…>; } ; `revision`: `number` }, `Promise`<`null`>>	-
`savedGraph`	`RegisteredQuery`<`"public"`, { `id`: `string` }, `Promise`<`AppSavedGraph`>>	-
`saveGraph`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `name`: `string` ; `graph`: `any` ; `revision`: `number` }, `Promise`<{ `id`: `string` ; `revision`: `number` }>>	-
`deleteGraph`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `revision`: `number` }, `Promise`<`null`>>	-
`catalog`	`RegisteredQuery`<`"public"`, {}, `Promise`<`AppCatalog`>>	-
`objects`	`RegisteredQuery`<`"public"`, { `collection`: `string` ; `ids`: `string`[] }, `Promise`<(`null` \| `GenericDocument`)[]>>	-
`labels`	`RegisteredQuery`<`"public"`, { `objects`: { id: string; collection: string; }[] }, `Promise`<`AppObjectLabel`[]>>	-
`search`	`RegisteredQuery`<`"public"`, { `text`: `string` }, `Promise`<{ `collection`: `string` = type.name; `label`: `string` ; `mode`: `AppSearchMode` ; `is_complete`: `boolean` ; `objects`: { `collection`: `string` = type.name; `id`: `Value` = row._id; `title`: `string` }[] }[]>>	-
`facets`	`RegisteredQuery`<`"public"`, { `within`: `undefined` \| { mode?: “contains” \| “within” \| “intersects” \| “disjoint”; field: string; region: any; } ; `search`: `undefined` \| `string` ; `related`: `undefined` \| { match?: “any” \| “all”; has?: “some” \| “none”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; relation: string; }[] ; `order`: `undefined` \| `"asc"` \| `"desc"` ; `filters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `ids`: `undefined` \| `string`[] ; `nearest`: `any` ; `filterMode`: `undefined` \| `"any"` \| `"all"` ; `groups`: `undefined` \| { match: “any” \| “all”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; }[] ; `asOf`: `undefined` \| `string` ; `analysisFilters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `orderBy`: `undefined` \| `string` ; `histogram`: `undefined` \| `string` ; `collection`: `string` }, `Promise`<`AppFacets`>>	-
`connections`	`RegisteredQuery`<`"public"`, { `where`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `order`: `undefined` \| `"asc"` \| `"desc"` ; `id`: `string` ; `collection`: `string` ; `paginationOpts`: { id?: number; endCursor?: string \| null; maximumRowsRead?: number; maximumBytesRead?: number; numItems: number; cursor: string \| null; } ; `relation`: `string` }, `Promise`<`AppPage`>>	-
`browse`	`RegisteredQuery`<`"public"`, { `within`: `undefined` \| { mode?: “contains” \| “within” \| “intersects” \| “disjoint”; field: string; region: any; } ; `search`: `undefined` \| `string` ; `related`: `undefined` \| { match?: “any” \| “all”; has?: “some” \| “none”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; relation: string; }[] ; `order`: `undefined` \| `"asc"` \| `"desc"` ; `filters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `ids`: `undefined` \| `string`[] ; `nearest`: `any` ; `filterMode`: `undefined` \| `"any"` \| `"all"` ; `groups`: `undefined` \| { match: “any” \| “all”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; }[] ; `asOf`: `undefined` \| `string` ; `analysisFilters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `orderBy`: `undefined` \| `string` ; `collection`: `string` ; `paginationOpts`: { id?: number; endCursor?: string \| null; maximumRowsRead?: number; maximumBytesRead?: number; numItems: number; cursor: string \| null; } }, `Promise`<`AppPage`>>	-
`summary`	`RegisteredQuery`<`"public"`, { `within`: `undefined` \| { mode?: “contains” \| “within” \| “intersects” \| “disjoint”; field: string; region: any; } ; `search`: `undefined` \| `string` ; `related`: `undefined` \| { match?: “any” \| “all”; has?: “some” \| “none”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; relation: string; }[] ; `order`: `undefined` \| `"asc"` \| `"desc"` ; `filters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `ids`: `undefined` \| `string`[] ; `nearest`: `any` ; `measure`: `undefined` \| `string` ; `filterMode`: `undefined` \| `"any"` \| `"all"` ; `groups`: `undefined` \| { match: “any” \| “all”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; }[] ; `asOf`: `undefined` \| `string` ; `analysisFilters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `cells`: `undefined` \| { system: “geohash” \| “h3”; resolution: number; } ; `bucket`: `undefined` \| `"day"` \| `"month"` \| `"week"` ; `pivotBy`: `undefined` \| `string` ; `orderBy`: `undefined` \| `string` ; `top`: `undefined` \| `number` ; `collection`: `string` ; `groupBy`: `string` }, `Promise`<`AppSummary`>>	-
`analysis`	`RegisteredQuery`<`"public"`, { `within`: `undefined` \| { mode?: “contains” \| “within” \| “intersects” \| “disjoint”; field: string; region: any; } ; `search`: `undefined` \| `string` ; `related`: `undefined` \| { match?: “any” \| “all”; has?: “some” \| “none”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; relation: string; }[] ; `order`: `undefined` \| `"asc"` \| `"desc"` ; `filters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `ids`: `undefined` \| `string`[] ; `nearest`: `any` ; `measure`: `undefined` \| `string` ; `filterMode`: `undefined` \| `"any"` \| `"all"` ; `groups`: `undefined` \| { match: “any” \| “all”; filters: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; }[] ; `asOf`: `undefined` \| `string` ; `analysisFilters`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `cells`: `undefined` \| { system: “geohash” \| “h3”; resolution: number; } ; `groupBy`: `undefined` \| `string` ; `bucket`: `undefined` \| `"day"` \| `"month"` \| `"week"` ; `pivotBy`: `undefined` \| `string` ; `orderBy`: `undefined` \| `string` ; `top`: `undefined` \| `number` ; `collection`: `string` ; `paginationOpts`: { id?: number; endCursor?: string \| null; maximumRowsRead?: number; maximumBytesRead?: number; numItems: number; cursor: string \| null; } }, `Promise`<`AppAnalysis`>>	-
`get`	`RegisteredQuery`<`"public"`, { `id`: `string` ; `collection`: `string` }, `Promise`<`null` \| `GenericDocument`>>	-
`getMany`	`RegisteredQuery`<`"public"`, { `collection`: `string` ; `ids`: `string`[] }, `Promise`<`AppPointRead`[]>>	-
`related`	`RegisteredQuery`<`"public"`, { `where`: `undefined` \| { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[] ; `id`: `string` ; `field`: `string` ; `collection`: `string` ; `paginationOpts`: { id?: number; endCursor?: string \| null; maximumRowsRead?: number; maximumBytesRead?: number; numItems: number; cursor: string \| null; } ; `relationship`: `string` }, `Promise`<`AppPage`>>	-
`searchAround`	`RegisteredQuery`<`"public"`, { `id`: `string` ; `collection`: `string` ; `hops`: { where?: { operator?: “contains” \| “eq” \| “gt” \| “gte” \| “lt” \| “lte” \| “in” \| “has_any” \| “has_none” \| “relative” \| “neq” \| “not_in” \| “between” \| “is_empty” \| “is_not_empty”; value: any; field: string; }[]; relation: string; }[] }, `Promise`<`AppSearchAround`>>	Search Around: from one starting object, follow one to three declared relations, keeping at each hop the distinct targets that match that hop’s `where` (see `AppSearchAround` and the relationships page). One request is one query at one basis. Every read is an ordinary read under the caller’s authority, so the engine decides disclosure for the whole answer: a refused read anywhere refuses this starting object’s answer, and the caller counts it as restricted without learning what it would have reached. The one exception is an incoming hop’s relation range, which withholds the targets the caller may not read, so the hop answers as if they did not exist. An incoming hop reads the declared relation index with `where` as a native filter; an outgoing hop point-reads the one referenced object and evaluates the same predicate over it. Both leave their dependencies in the read set, so a subscription is invalidated by any write that changes the answer. Bounds: `SEARCH_AROUND_FANOUT` matches per reached object and hop, `SEARCH_AROUND_OBJECTS` distinct objects per hop, `SEARCH_RANGE_ROWS` + 1 rows visited per incoming range, `SEARCH_VISITS` rows per request and the read-subject budget. Each hop may spend an equal share of what remains, and each reached object an equal share of its hop’s (at least two rows while the hop can pay), an unused share carrying forward. A hop stopped by any bound, or following an incomplete hop, is reported incomplete: it is never an error and never a total.
`accessRequests`	`RegisteredQuery`<`"public"`, {}, `Promise`<`AppAccessRequestPage`>>	The access requests this caller may see among the exposed operations: their own, and those they may currently decide. Read only: filing, withdrawing and deciding go to the deployment’s native `POST /api/access_requests` with the caller’s own token, so no function in this program can make those writes for anyone.
`activity`	`RegisteredQuery`<`"public"`, { `target`: `undefined` \| { id: string; view: string; } ; `cursor`: `null` \| `string` ; `is_held`: `boolean` }, `Promise`<`AppActivityPage`>>	-
`dependencyStatus`	`RegisteredQuery`<`"public"`, { `id`: `undefined` \| `string` ; `collection`: `string` }, `Promise`<`AppDependencyStatus`>>	-
`sourceSyncs`	`RegisteredQuery`<`"public"`, { `source`: `undefined` \| `string` ; `collection`: `string` }, `Promise`<`AppSourceSyncsPage`>>	-
`requestSourceSync`	`RegisteredMutation`<`"public"`, { `source`: `string` ; `collection`: `string` }, `Promise`<`AppSourceSyncRequest`>>	-
`requestConnectionCheck`	`RegisteredMutation`<`"public"`, { `source`: `string` ; `collection`: `string` }, `Promise`<`AppConnectionCheckRequest`>>	-
`mapSettings`	`RegisteredQuery`<`"public"`, {}, `Promise`<`AppMapSettingsView`>>	-
`saveMapSettings`	`RegisteredMutation`<`"public"`, { `revision`: `number` ; `settings`: `any` }, `Promise`<{ `revision`: `number` }>>	-
`overlayLayers`	`RegisteredQuery`<`"public"`, {}, `Promise`<`AppOverlayListing`[]>>	-
`overlayLayer`	`RegisteredQuery`<`"public"`, { `id`: `string` }, `Promise`<`AppSavedOverlay`>>	-
`saveOverlayLayer`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `name`: `string` ; `revision`: `number` ; `sharing`: `any` ; `overlay`: `any` }, `Promise`<{ `id`: `string` }>>	-
`deleteOverlayLayer`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `revision`: `number` }, `Promise`<`null`>>	-
`recordMapExport`	`RegisteredMutation`<`"public"`, { `kind`: `string` ; `map`: `null` \| `string` ; `name`: `string` ; `layers`: `any`[] }, `Promise`<{ `id`: `string` }>>	-
`mapExports`	`RegisteredQuery`<`"public"`, { `cursor`: `null` \| `string` }, `Promise`<{ `page`: `AppMapExport`[] ; `cursor`: `null` \| `string` }>>	-
`mapTile`	`RegisteredAction`<`"public"`, { `x`: `number` ; `y`: `number` ; `basemap`: `string` ; `z`: `number` }, `Promise`<`AppMapTile`>>	-
`savedMap`	`RegisteredQuery`<`"public"`, { `id`: `string` }, `Promise`<`AppSavedMap`>>	-
`saveMap`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `name`: `string` ; `document`: `any` ; `revision`: `number` ; `sharing`: `any` }, `Promise`<{ `id`: `string` }>>	-
`deleteMap`	`RegisteredMutation`<`"public"`, { `id`: `string` ; `revision`: `number` }, `Promise`<`null`>>	-
`mediaUrls`	`RegisteredQuery`<`"public"`, { `property`: `string` ; `collection`: `string` ; `ids`: `string`[] }, `Promise`<{ `urls`: `Record`<`string`, `null` \| `string`> ; `restricted`: `number` }>>	-
`notifications`	`RegisteredQuery`<`"public"`, { `kind`: `undefined` \| `string` ; `status`: `"all"` \| `"unread"` \| `"archived"` ; `paginationOpts`: { id?: number; endCursor?: string \| null; maximumRowsRead?: number; maximumBytesRead?: number; numItems: number; cursor: string \| null; } }, `Promise`<`AppNotificationPage`>>	-
`updateNotification`	`RegisteredMutation`<`"public"`, { `is_read`: `undefined` \| `boolean` ; `is_archived`: `undefined` \| `boolean` ; `id`: `string` }, `Promise`<`null`>>	-
`markNotificationsRead`	`RegisteredMutation`<`"public"`, { `ids`: `string`[] }, `Promise`<`null`>>	Mark up to MAX_RESOLVED_NOTIFICATIONS of the caller’s own notifications read in one transaction. Every id is checked exactly as `updateNotification` checks one (ownership, then resolution under current reads, three read subjects each), and any id that fails refuses the whole request, so either all of them are marked or none is. A row already read is left unwritten.
`observeScope`	`RegisteredQuery`<`"internal"`, { `mode`: `"validate"` \| `"observe"` ; `properties`: `string`[] ; `limit`: `number` ; `scope`: `any` ; `measure`: `null` \| { kind: “count”; } \| { kind: “sum”; property: string; } ; `asOf`: `string` }, `Promise`<`AppObservation`>>	-
`placeSearch`	`RegisteredMutation`<`"public"`, { `text`: `string` }, `Promise`<{ `id`: `string` }>>	-
`placeResult`	`RegisteredQuery`<`"public"`, { `id`: `string` }, `Promise`<`null` \| `AppPlaceSearch`>>	-
`mapValues`	`RegisteredQuery`<`"public"`, { `name`: `string` ; `ids`: `string`[] }, `Promise`<{ `values`: `Record`<`string`, `null` \| `string` \| `number`> ; `restricted`: `number` }>>	-
`seriesLatest`	`RegisteredQuery`<`"public"`, { `measures`: `undefined` \| `string`[] ; `property`: `string` ; `collection`: `string` ; `ids`: `string`[] }, `Promise`<`AppSeriesLatest`>>	The latest point of up to SERIES_LATEST_IDS objects’ declared series property (a map layer’s positions). The objects are read first in one restrictable point read: each one the caller may not read is counted in `restricted` and gets no series data, and the rest of the answer stands. An object whose series the type’s markings withhold from the caller (seriesReadable) is counted in `restricted` too. Each reader call runs in this query with the caller’s context, so a new report invalidates the subscription.
`seriesSearch`	`RegisteredQuery`<`"public"`, { `limit`: `undefined` \| `number` ; `property`: `string` ; `to`: `string` ; `area`: `any` ; `from`: `string` ; `collection`: `string` }, `Promise`<`AppSeriesSearchResult`>>	The objects whose recorded track of a declared series property within `[from, to]` (at most a day) meets a drawn area, through the reader’s `search`. The matched objects are then read in one restrictable point read: each one the caller may not read is counted in `restricted` and not named, and each named object must hold the matched series id in its declared id property. The reader runs in this query with the caller’s context, so a new report in the window invalidates it.
`seriesMeasure`	`RegisteredQuery`<`"public"`, { `to`: `undefined` \| `string` ; `maxPoints`: `undefined` \| `number` ; `property`: `string` ; `id`: `string` ; `from`: `string` ; `collection`: `string` ; `measure`: `string` }, `Promise`<`AppSeriesMeasure`>>	One measure of an object’s declared series property over a window (at most SERIES_MAX_WINDOW_MS; `to` omitted is an open window whose tail grows with each committed report), at most `maxPoints` points downsampled by the reader. The object is read first through the authorized `get`, then the markings guard (seriesReadable): a caller it does not clear reads `withheld` with nothing else. The measure is a built-in or one the property declares; any other is refused.
`series`	`RegisteredQuery`<`"public"`, { `to`: `undefined` \| `string` ; `from`: `undefined` \| `string` ; `maxPoints`: `undefined` \| `number` ; `log`: `undefined` \| `number` ; `property`: `string` ; `id`: `string` ; `collection`: `string` }, `Promise`<`AppSeriesResult`>>	-

applicationNotificationRow

▸ applicationNotificationRow(args): Object One delivery row, as the notification table stores it: recipient a person id and event the occurrence reference kind resolves, each at most APP_NOTICE_REFERENCE_MAX characters. The row holds references only, never content.

Parameters

Name	Type
`args`	`Object`
`args.recipient`	`string`
`args.kind`	`string`
`args.event`	`string`

Returns

Object

Name	Type
`recipient`	`string`
`event_id`	`string`
`kind`	`string`
`is_read`	`false`
`is_archived`	`false`

applicationPerson

▸ applicationPerson(people, ctx): Promise<string | null> The caller’s own person, as people.self answers it, normalized to an id of the people collection; null without people or when the caller is not one of them. An answer that is not such an id (at most APP_NOTICE_REFERENCE_MAX characters) is refused. Call it after authorize: it is the one resolution of “who is the caller” that the application’s own queries and a capability’s exposure helpers share.

Parameters

Name	Type
`people`	`undefined` \| `ApplicationPeople`
`ctx`	`GenericQueryCtx`<`GenericDataModel`>

Returns

Promise<string | null>

createFunctionHandle

▸ createFunctionHandle<Type, Args, ReturnType>(functionReference): Promise<FunctionHandle<Type, Args, ReturnType>> Create a serializable reference to a Bijection function. Passing a this reference to another component allows that component to call this function during the current function execution or at any later time. Function handles are used like api.folder.function FunctionReferences, e.g. ctx.scheduler.runAfter(0, functionReference, args). A function reference is stable across code pushes but it’s possible the Bijection function it refers to might no longer exist. This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.

Type parameters

Name	Type
`Type`	extends `FunctionType`
`Args`	extends `DefaultFunctionArgs`
`ReturnType`	`ReturnType`

Parameters

Name	Type
`functionReference`	`FunctionReference`<`Type`, `"public"` \| `"internal"`, `Args`, `ReturnType`> \| `FunctionReference_future`<`Type`, `"public"` \| `"internal"`, `Args`, `ReturnType`>

Returns

Promise<FunctionHandle<Type, Args, ReturnType>>

defineComponent

▸ defineComponent<Exports, Env>(name, options?): ComponentDefinition<Exports, Env> Define a component, a piece of a Bijection deployment with namespaced resources. Optionally define typed environment variables that will be available via the env export from _generated/server in all Bijection functions within this component. Values are passed by the parent via app.use(component, { env: { ... } }).

Type parameters

Name	Type
`Exports`	extends `ComponentExports` = `any`
`Env`	extends `EnvDefinition` = {}

Parameters

Name	Type	Description
`name`	`string`	Name must be alphanumeric plus underscores. Typically these are lowercase with underscores like `"onboarding_flow_tracker"`. This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.
`options?`	`Object`	-
`options.env?`	`Env`	-

Returns

ComponentDefinition<Exports, Env>

defineApp

▸ defineApp<Env>(options?): AppDefinition<Env> Attach components, reuseable pieces of a Bijection deployment, to this Bijection app. Optionally define typed environment variables that will be available via the env export from _generated/server in all Bijection functions. Example

import { defineApp } from "bijection/server";
import { v } from "bijection/values";

const app = defineApp({
  env: {
    OPENAI_API_KEY: v.string(),
    DEBUG_MODE: v.optional(v.string()),
  },
});
export default app;

This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.

Type parameters

Name	Type
`Env`	extends `EnvDefinition` = `EnvDefinition`

Parameters

Name	Type
`options?`	`Object`
`options.httpPrefix?`	`string`
`options.env?`	`Env`

Returns

AppDefinition<Env>

componentsGeneric

▸ componentsGeneric(): AnyChildComponents

Returns

AnyChildComponents

getFunctionAddress

▸ getFunctionAddress(functionReference): { functionHandle: string = functionReference; reference?: undefined = referencePath; name?: undefined = body.name } | { functionHandle?: undefined = functionReference; name: any ; reference?: undefined = referencePath } | { functionHandle?: undefined = functionReference; reference: string = referencePath; name?: undefined = body.name }

Parameters

Name	Type
`functionReference`	`any`

Returns

{ functionHandle: string = functionReference; reference?: undefined = referencePath; name?: undefined = body.name } | { functionHandle?: undefined = functionReference; name: any ; reference?: undefined = referencePath } | { functionHandle?: undefined = functionReference; reference: string = referencePath; name?: undefined = body.name }

bijectionQueryGeneric

▸ bijectionQueryGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(definition): RegisteredQuery<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`definition`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `capabilities?`: `undefined` ; `handler`: (`ctx`: `BijectionQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `BijectionQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredQuery<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

bijectionInternalQueryGeneric

▸ bijectionInternalQueryGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(definition): RegisteredQuery<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`definition`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `capabilities?`: `undefined` ; `handler`: (`ctx`: `BijectionQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `BijectionQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredQuery<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

bijectionMutationGeneric

▸ bijectionMutationGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(definition): RegisteredMutation<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`definition`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `capabilities?`: `undefined` ; `handler`: (`ctx`: `BijectionMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `BijectionMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredMutation<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

bijectionInternalMutationGeneric

▸ bijectionInternalMutationGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(definition): RegisteredMutation<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`definition`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `capabilities?`: `undefined` ; `handler`: (`ctx`: `BijectionMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `BijectionMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredMutation<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

bijectionActionGeneric

▸ bijectionActionGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(definition): RegisteredAction<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`definition`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `capabilities?`: { `functions`: readonly `FunctionReference`<`any`, `"public"` \| `"internal"`>[] } ; `handler`: (`ctx`: `BijectionActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `BijectionActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredAction<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

bijectionInternalActionGeneric

▸ bijectionInternalActionGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(definition): RegisteredAction<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`definition`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `capabilities?`: { `functions`: readonly `FunctionReference`<`any`, `"public"` \| `"internal"`>[] } ; `handler`: (`ctx`: `BijectionActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `BijectionActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredAction<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue>

cronJobs

▸ cronJobs(): Crons Create a CronJobs object to schedule recurring tasks.

// bijection/crons.js
import { cronJobs } from 'bijection/server';
import { api } from "./_generated/api";

const crons = cronJobs();
crons.weekly(
  "weekly re-engagement email",
  {
    hourUTC: 17, // (9:30am Pacific/10:30am Daylight Savings Pacific)
    minuteUTC: 30,
  },
  api.emails.send
)
export default crons;

Returns

Crons

externalCallStatus

▸ externalCallStatus(_ctx, id): Promise<ExternalCallStatus> The status of a governed call this component submitted with ctx.externalCalls.submit. A tracked read: a query that asks is re-run when the call settles. A call another component submitted, or an id that names nothing, is refused as not found.

Parameters

Name	Type
`_ctx`	`GenericMutationCtx`<`GenericDataModel`> \| `GenericQueryCtx`<`GenericDataModel`>
`id`	`ExternalCallId`

Returns

Promise<ExternalCallStatus>

bothAccessResults

▸ bothAccessResults(...results): GoverningResult Combine rule results: null only when none carries a bound, otherwise the earliest validUntil. A result’s reason says why it permitted and bounds nothing.

Parameters

Name	Type
`...results`	`ReadAccessResult`[]

Returns

GoverningResult

defineAccessModel

▸ defineAccessModel(definition): Object Declare the access model. Throws on an inconsistent declaration.

Parameters

Name	Type
`definition`	`AccessModelDefinition`

Returns

Object

Name	Type
`inputs`	() => `string`[]
`grantsTableName`	`string`
`grantsTable`	() => `TableDefinition`<`VObject`<{ `reason`: `undefined` \| `string` ; `expiresAt`: `undefined` \| `number` ; `subjectPermission`: `undefined` \| `string` ; `object`: `string` ; `type`: `string` ; `subject`: `string` ; `role`: `string` ; `subjectKind`: `"group"` \| `"user"` ; `subjectType`: `string` }, { `type`: `VString`<`string`, `"required"`> ; `object`: `VString`<`string`, `"required"`> ; `role`: `VString`<`string`, `"required"`> ; `subjectKind`: `VUnion`<`"group"` \| `"user"`, [`VLiteral`<`"user"`, `"required"`>, `VLiteral`<`"group"`, `"required"`>], `"required"`, `never`> ; `subjectType`: `VString`<`string`, `"required"`> ; `subject`: `VString`<`string`, `"required"`> ; `subjectPermission`: `VString`<`undefined` \| `string`, `"optional"`> ; `expiresAt`: `VFloat64`<`undefined` \| `number`, `"optional"`> ; `reason`: `VString`<`undefined` \| `string`, `"optional"`> }, `"required"`, `"object"` \| `"type"` \| `"subject"` \| `"reason"` \| `"expiresAt"` \| `"role"` \| `"subjectKind"` \| `"subjectType"` \| `"subjectPermission"`>, { `by_subject`: [`"subjectKind"`, `"subjectType"`, `"subject"`, `"subjectPermission"`, `"type"`, `"object"`, `"_creationTime"`] ; `by_object`: [`"type"`, `"object"`, `"subjectKind"`, `"role"`, `"subject"`, `"_creationTime"`] ; `by_role`: [`"role"`, `"type"`, `"object"`, `"_creationTime"`] }, {}, {}, `false`>
`read`	(`type`: `string`) => (`ctx`: `AccessCtx`, `__namedParameters`: `ReadAccessArgs`) => `Promise`<`ReadAccessResults`>
`disclose`	(`type`: `string`, `options`: { `alsoTo?`: readonly `string`[] }) => (`ctx`: `AccessCtx`, `args`: `DisclosureArgs`) => `Promise`<`ReadAccessResults`>
`write`	(`type`: `string`) => (`ctx`: `AccessCtx`, `__namedParameters`: { `changes`: `TableChange`<`any`>[] }) => `Promise`<`ReadAccessResults`>
`grantsRead`	(`ctx`: `AccessCtx`, `__namedParameters`: `ReadAccessArgs`) => `Promise`<`ReadAccessResults`>
`grantsWrite`	(`ctx`: `AccessCtx`, `__namedParameters`: { `changes`: `TableChange`<`GrantDocument`>[] }) => `Promise`<`ReadAccessResults`>
`grantsDisclose`	(`ctx`: `AccessCtx`, `__namedParameters`: `DisclosureArgs`) => `Promise`<`ReadAccessResults`>
`roleDefinitionsTable`	() => `TableDefinition`<`VObject`<{ `maxDuration`: `undefined` \| `number` ; `type`: `string` ; `name`: `string` ; `permissions`: `string`[] ; `scope`: `string` }, { `scope`: `VString`<`string`, `"required"`> ; `type`: `VString`<`string`, `"required"`> ; `name`: `VString`<`string`, `"required"`> ; `permissions`: `VArray`<`string`[], `VString`<`string`, `"required"`>, `"required"`> ; `maxDuration`: `VFloat64`<`undefined` \| `number`, `"optional"`> }, `"required"`, `"type"` \| `"name"` \| `"permissions"` \| `"scope"` \| `"maxDuration"`>, { `by_scope`: [`"scope"`, `"type"`, `"name"`, `"_creationTime"`] }, {}, {}, `false`>
`roleDefinitionsRead`	(`ctx`: `AccessCtx`, `__namedParameters`: `ReadAccessArgs`) => `Promise`<`ReadAccessResults`>
`roleDefinitionsWrite`	(`ctx`: `AccessCtx`, `__namedParameters`: { `changes`: `TableChange`<`RoleDefinitionDocument`>[] }) => `Promise`<`ReadAccessResults`>
`roleDefinitionsDisclose`	(`ctx`: `AccessCtx`, `__namedParameters`: `DisclosureArgs`) => `Promise`<`ReadAccessResults`>
`can`	(`ctx`: `AccessCtx`, `permission`: `string`, `type`: `string`, `key`: `string`) => `Promise`<`GoverningResult`>
`audited`	(`ctx`: `AccessCtx`, `permission`: `string`, `type`: `string`, `key`: `string`) => `Promise`<`GoverningResult`>
`permissionsOn`	(`ctx`: `AccessCtx`, `type`: `string`, `key`: `string`) => `Promise`<`string`[]>
`explain`	(`ctx`: `AccessCtx`, `permission`: `string`, `type`: `string`, `key`: `string`) => `Promise`<{ `allowed`: `boolean` ; `path?`: `AccessPath` ; `refusedBy?`: `string` }>
`visible`	(`ctx`: `AccessCtx`, `type`: `string`, `options`: { `permission?`: `string` ; `limit?`: `number` }) => `Promise`<`string`[]>
`holders`	(`ctx`: `AccessCtx`, `type`: `string`, `key`: `string`) => `Promise`<{ `on`: `string` ; `grants`: `GrantDocument`[] ; `rowGrants`: { `field`: `string` ; `role`: `string` ; `keys`: `string`[] }[] ; `directories`: { `table`: `string` ; `role`: `string` }[] }[]>
`grant`	(`ctx`: `AccessMutationCtx`, `input`: `GrantInput`, `options`: `GrantOptions`) => `Promise`<`GenericId`<`string`>>
`recertify`	(`ctx`: `AccessMutationCtx`, `id`: `GenericId`<`string`>, `renewal`: { `expiresAt`: `number` ; `reason?`: `string` }, `options`: `GrantOptions` & { `expire`: `GrantMutation` }) => `Promise`<`GenericId`<`string`>>
`reviewDue`	(`ctx`: { `db`: `GenericDatabaseReader`<`any`> ; `audit?`: (`body`: `AuditLogBody`) => `Promise`<`void`> }, `__namedParameters`: { `id`: `GenericId`<`string`> }) => `Promise`<`GrantDocument` \| `null`>
`expireGrant`	(`ctx`: { `db`: `GenericDatabaseWriter`<`any`> ; `audit?`: (`body`: `AuditLogBody`) => `Promise`<`void`> }, `__namedParameters`: { `id`: `GenericId`<`string`> }) => `Promise`<`null`>
`revokeAll`	(`ctx`: { `db`: `GenericDatabaseWriter`<`any`> ; `audit?`: (`body`: `AuditLogBody`) => `Promise`<`void`> }, `type`: `string`, `key`: `string`) => `Promise`<`number`>
`both`	(…`results`: `ReadAccessResult`[]) => `GoverningResult`
`rowsFollowRange`	(`type`: `string`) => { `index`: `string` = t.parent.index; `field`: `string` = t.parent.field; `markings?`: `string` = t.restrictionField.name }[]
`cedar`	() => `AccessCedarPolicies`
`cedarEntities`	(`tables`: `Record`<`string`, readonly `Record`<`string`, `unknown`>[]>, `now`: `number`, `coverage?`: (`sourceId`: `string`, `table`: `string`) => `null` \| `AccessDirectoryCoverage`) => `AccessCedarEntities`
`cedarContext`	(`identity`: `null` \| `UserIdentity`) => `Record`<`string`, `unknown`>
`describe`	() => { `grants`: `string` = m.grants; `categories`: {} ; `groups`: { `types`: `string`[] ; `depth`: `number` = m.depth } ; `directories`: { `table`: `string` ; `index`: `string` ; `type`: `string` ; `role`: `string` ; `object`: `string` ; `member`: `string` ; `maxAge`: `number` }[] ; `users`: `null` \| { `table`: `string` ; `index`: `string` ; `user`: `string` } ; `roleDefinitions`: `null` \| { `table`: `string` ; `scope`: `string` } ; `claims`: {} ; `conditions`: { `name`: `string` = c.name; `on`: `null` \| `string`[] ; `claims`: `string`[] }[] ; `requestScope`: { `objects?`: `string` ; `permissions?`: `string` } ; `audit`: `boolean` = m.audit; `types`: { `name`: `string` = t.name; `table`: `undefined` \| `string` = t.table; `parent`: `null` \| `string` ; `parentField`: `null` \| `string` ; `permissions`: `string`[] ; `visibility`: `string` = t.visibility; `rowGrants`: { `field`: `string` ; `role`: `string` ; `members?`: { `type`: `string` ; `permission`: `string` } }[] ; `restrictions`: { `root`: `null` \| { `type`: `string` ; `category`: `string` } ; `field`: `null` \| { `name`: `string` ; `type`: `string` } } ; `category`: `null` \| `string` \| { `from`: `"key"` } }[] ; `roles`: { `name`: `string` = r.name; `permissions`: `string`[] ; `maxDuration`: `undefined` \| `number` = r.maxDuration; `justification`: `boolean` = r.justification; `selfGrant`: `null` \| `string` }[] }

getServiceToken

▸ getServiceToken(service): Promise<string> Get a short-lived credential for calling a Bijection-managed service. This function can only be called while an action is running. The credential is scoped to the current deployment and should be sent as a bearer token. The action runtime caches and refreshes credentials as needed, so call this function whenever making a service request.

Parameters

Name	Type	Description
`service`	`"ai-gateway"`	The service the credential may access.

Returns

Promise<string> A JWT to send as Authorization: Bearer <token>. Keep it inside the action: don’t return it to clients or store it in environment variables.

getServiceUrl

▸ getServiceUrl(service): Promise<string> Get the base URL of a Bijection-managed service. This function can only be called while an action is running. Pair it with getServiceToken to reach the service.

Parameters

Name	Type	Description
`service`	`"ai-gateway"`	The service to address.

Returns

Promise<string> The service’s origin, without a trailing slash.

mutationGeneric

▸ mutationGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation): RegisteredMutation<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Define a mutation in this Bijection app’s public API. You should generally use the mutation function from "./_generated/server". Mutations can read from and write to the database, and are accessible from the client. They run transactionally, all database reads and writes within a single mutation are atomic and isolated from other mutations. Example

import { mutation } from "./_generated/server";
import { v } from "bijection/values";

export const createTask = mutation({
  args: { text: v.string() },
  returns: v.id("tasks"),
  handler: async (ctx, args) => {
    const taskId = await ctx.db.insert("tasks", {
      text: args.text,
      completed: false,
    });
    return taskId;
  },
});

Best practice: Always include args and returns validators on all mutations. If the function doesn’t return a value, use returns: v.null(). Argument validation is critical for security since public mutations are exposed to the internet. Common mistake: Mutations cannot call third-party APIs or use fetch. They must be deterministic. Use actions for external API calls. Common mistake: Do not use mutation for sensitive internal functions that should not be called by clients. Use internalMutation instead. See https://docs.bijection.com/functions/mutation-functions

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`mutation`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredMutation<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> The wrapped mutation. Include this as an export to name it and make it accessible.

internalMutationGeneric

▸ internalMutationGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation): RegisteredMutation<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Define a mutation that is only accessible from other Bijection functions (but not from the client). You should generally use the internalMutation function from "./_generated/server". Internal mutations can read from and write to the database but are not exposed as part of your app’s public API. They can only be called by other Bijection functions using ctx.runMutation or by the scheduler. Like public mutations, they run transactionally. Example

import { internalMutation } from "./_generated/server";
import { v } from "bijection/values";

// This mutation can only be called from other Bijection functions:
export const markTaskCompleted = internalMutation({
  args: { taskId: v.id("tasks") },
  returns: v.null(),
  handler: async (ctx, args) => {
    await ctx.db.patch("tasks", args.taskId, { completed: true });
    return null;
  },
});

Best practice: Use internalMutation for any mutation that should not be directly callable by clients, such as write-back functions from actions or scheduled background work. Reference it via the internal object: await ctx.runMutation(internal.myModule.markTaskCompleted, { taskId }). See https://docs.bijection.com/functions/internal-functions

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`mutation`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericMutationCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredMutation<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> The wrapped mutation. Include this as an export to name it and make it accessible.

queryGeneric

▸ queryGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query): RegisteredQuery<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Define a query in this Bijection app’s public API. You should generally use the query function from "./_generated/server". Queries can read from the database and are accessible from the client. They are reactive, when used with useQuery in React, the component automatically re-renders whenever the underlying data changes. Queries cannot modify the database. Query results are automatically cached by the Bijection client and kept consistent via WebSocket subscriptions. Example

import { query } from "./_generated/server";
import { v } from "bijection/values";

export const listTasks = query({
  args: { completed: v.optional(v.boolean()) },
  returns: v.array(v.object({
    _id: v.id("tasks"),
    _creationTime: v.number(),
    text: v.string(),
    completed: v.boolean(),
  })),
  handler: async (ctx, args) => {
    if (args.completed !== undefined) {
      return await ctx.db
        .query("tasks")
        .withIndex("by_completed", (q) => q.eq("completed", args.completed))
        .collect();
    }
    return await ctx.db.query("tasks").collect();
  },
});

Best practice: Always include args and returns validators. Use .withIndex() instead of .filter() for efficient database queries. Queries should be fast since they run on every relevant data change. Common mistake: Queries are pure reads, they cannot write to the database, call external APIs, or schedule functions. Use actions for HTTP calls and mutations for database writes and scheduling. See https://docs.bijection.com/functions/query-functions

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`query`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredQuery<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> The wrapped query. Include this as an export to name it and make it accessible.

internalQueryGeneric

▸ internalQueryGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query): RegisteredQuery<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Define a query that is only accessible from other Bijection functions (but not from the client). You should generally use the internalQuery function from "./_generated/server". Internal queries can read from the database but are not exposed as part of your app’s public API. They can only be called by other Bijection functions using ctx.runQuery. This is useful for loading data in actions or for helper queries that shouldn’t be client-facing. Example

import { internalQuery } from "./_generated/server";
import { v } from "bijection/values";

// Only callable from other Bijection functions:
export const getUser = internalQuery({
  args: { userId: v.id("users") },
  returns: v.union(
    v.object({
      _id: v.id("users"),
      _creationTime: v.number(),
      name: v.string(),
      email: v.string(),
    }),
    v.null(),
  ),
  handler: async (ctx, args) => {
    return await ctx.db.get("users", args.userId);
  },
});

Best practice: Use internalQuery for data-loading in actions via ctx.runQuery(internal.myModule.getUser, { userId }). See https://docs.bijection.com/functions/internal-functions

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type
`query`	{ `args?`: `ArgsValidator` ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericQueryCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`

Returns

RegisteredQuery<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> The wrapped query. Include this as an export to name it and make it accessible.

actionGeneric

▸ actionGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(func): RegisteredAction<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Define an action in this Bijection app’s public API. Actions can call third-party APIs, use Node.js libraries, and perform other side effects. Unlike queries and mutations, actions do not have direct database access (ctx.db is not available). Instead, use ctx.runQuery and ctx.runMutation to read and write data. You should generally use the action function from "./_generated/server". Actions are accessible from the client and run outside of the database transaction, so they are not atomic. They are best for integrating with external services. Example

// Add "use node"; at the top of the file if using Node.js built-in modules.
import { action } from "./_generated/server";
import { v } from "bijection/values";
import { internal } from "./_generated/api";

export const generateSummary = action({
  args: { text: v.string() },
  returns: v.string(),
  handler: async (ctx, args) => {
    // Call an external API:
    const response = await fetch("https://api.example.com/summarize", {
      method: "POST",
      body: JSON.stringify({ text: args.text }),
    });
    const { summary } = await response.json();

    // Write results back via a mutation:
    await ctx.runMutation(internal.myModule.saveSummary, {
      text: args.text,
      summary,
    });

    return summary;
  },
});

Best practice: Minimize the number of ctx.runQuery and ctx.runMutation calls from actions. Each call is a separate transaction, so splitting logic across multiple calls introduces the risk of race conditions. Try to batch reads/writes into single query/mutation calls. "use node" runtime: Actions run in Bijection’s default JavaScript runtime, which supports fetch and most NPM packages. Only add "use node"; at the top of the file if a third-party library specifically requires Node.js built-in APIs, it is a last resort, not the default. Node.js actions have slower cold starts, and only actions can be defined in "use node" files (no queries or mutations), so prefer the default runtime whenever possible. Common mistake: Do not try to access ctx.db in an action, it is not available. Use ctx.runQuery and ctx.runMutation instead. See https://docs.bijection.com/functions/actions

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type	Description
`func`	{ `args?`: `ArgsValidator` ; `capabilities?`: { `functions`: readonly `FunctionReference`<`"query"` \| `"mutation"` \| `"action"`, `"public"` \| `"internal"`>[] } ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`	The function. It receives a GenericActionCtx as its first argument.

Returns

RegisteredAction<"public", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> The wrapped function. Include this as an export to name it and make it accessible.

internalActionGeneric

▸ internalActionGeneric<ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(func): RegisteredAction<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> Define an action that is only accessible from other Bijection functions (but not from the client). You should generally use the internalAction function from "./_generated/server". Internal actions behave like public actions (they can call external APIs and use Node.js libraries) but are not exposed in your app’s public API. They can only be called by other Bijection functions using ctx.runAction or via the scheduler. Example

import { internalAction } from "./_generated/server";
import { v } from "bijection/values";

export const sendEmail = internalAction({
  args: { to: v.string(), subject: v.string(), body: v.string() },
  returns: v.null(),
  handler: async (ctx, args) => {
    // Call an external email service (fetch works in the default runtime):
    await fetch("https://api.email-service.com/send", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(args),
    });
    return null;
  },
});

Best practice: Use internalAction for background work scheduled from mutations: await ctx.scheduler.runAfter(0, internal.myModule.sendEmail, { ... }). Only use ctx.runAction from another action if you need to cross runtimes (e.g., default Bijection runtime to Node.js). Otherwise, extract shared code into a helper function. "use node" runtime: Only add "use node"; at the top of the file as a last resort when a third-party library requires Node.js APIs. Node.js actions have slower cold starts, and only actions can be defined in "use node" files (no queries or mutations). See https://docs.bijection.com/functions/internal-functions

Type parameters

Name	Type
`ArgsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnsValidator`	extends `void` \| `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`ReturnValue`	extends `any` = `any`
`OneOrZeroArgs`	extends `ArgsArray` \| `OneArgArray`<`Infer`<`ArgsValidator`>> \| `OneArgArray`<`Expand`<{ [Property in string \| number \| symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string \| number \| symbol]: Infer<ArgsValidator[Property]> }>> = `DefaultArgsForOptionalValidator`<`ArgsValidator`>

Parameters

Name	Type	Description
`func`	{ `args?`: `ArgsValidator` ; `capabilities?`: { `functions`: readonly `FunctionReference`<`"query"` \| `"mutation"` \| `"action"`, `"public"` \| `"internal"`>[] } ; `returns?`: `ReturnsValidator` ; `handler`: (`ctx`: `GenericActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue` } \| (`ctx`: `GenericActionCtx`<`any`>, …`args`: `OneOrZeroArgs`) => `ReturnValue`	The function. It receives a GenericActionCtx as its first argument.

Returns

RegisteredAction<"internal", ArgsArrayToObject<OneOrZeroArgs>, ReturnValue> The wrapped function. Include this as an export to name it and make it accessible.

httpActionGeneric

▸ httpActionGeneric(func): PublicHttpAction Define a Bijection HTTP action. HTTP actions handle raw HTTP requests and return HTTP responses. They are registered by routing URL paths to them in bijection/http.ts using HttpRouter. Like regular actions, they can call external APIs and use ctx.runQuery / ctx.runMutation but do not have direct ctx.db access. Example

// bijection/http.ts
import { httpRouter } from "bijection/server";
import { httpAction } from "./_generated/server";

const http = httpRouter();

http.route({
  path: "/api/webhook",
  method: "POST",
  handler: httpAction(async (ctx, request) => {
    const body = await request.json();
    // Process the webhook payload...
    return new Response(JSON.stringify({ ok: true }), {
      status: 200,
      headers: { "Content-Type": "application/json" },
    });
  }),
});

export default http;

Best practice: HTTP actions are registered at the exact path specified. For example, path: "/api/webhook" registers at /api/webhook. See https://docs.bijection.com/functions/http-actions

Parameters

Name	Type	Description
`func`	(`ctx`: `GenericActionCtx`<`GenericDataModel`>, `request`: `Request`) => `Promise`<`Response`>	The function. It receives a GenericActionCtx as its first argument, and a `Request` object as its second.

Returns

PublicHttpAction The wrapped function. Route a URL path to this function in bijection/http.ts.

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

validateSetupDeclaration

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

Parameters

Name	Type
`setup`	`SetupDeclaration`

Returns

SetupDeclaration

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[]

admitIntegration

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

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

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

Type parameters

Name	Type
`T`	extends `Object`

Parameters

Name	Type
`definition`	`T`

Returns

T

defineIntegration

▸ defineIntegration<S, A, H>(definition): Object Define source collections, sync routines and external command contracts. Compiler addresses are references, never capabilities or trusted evidence.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`A`	extends `Record`<`string`, `Fields`>
`H`	extends `HttpContracts` = {}

Parameters

Name	Type
`definition`	`Object`

Returns

Object

defineNativeIntegration

▸ defineNativeIntegration<S, H, A>(definition): { commands: { readonly [K in string | number | symbol]: CommandHandle<ObjectType<A[K]>> } ; isIntegration: true ; discover?: (ctx: IntegrationContext<H>, input: { resume: null | string ; next_page_reference: null | string }) => Promise<{ resources: { id: string ; label: null | string }[] ; next_page: null | string ; evidence: string }> = definition.discover; invokeIntegration: (handler: (ctx: IntegrationContext<H>, …args: any[]) => unknown, argsStr: string) => Promise<string> ; [attachment]: (next: IntegrationAddress) => void ; exportIntegration: () => string } & { readonly [K in string | number | symbol]: SourceHandle<S[K]> } Native protocols use the same analyzed source handles as HTTP integrations. Their read entrypoints are implemented by the host; there are no guest callbacks with hidden network or evidence authority.

Type parameters

Name	Type
`S`	extends `Record`<`string`, `Fields`>
`H`	extends `HttpContracts` = {}
`A`	extends `Record`<`string`, `Fields`> = {}

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.transport`	`AcquisitionTransport`	-
`definition.http?`	`H`	-
`definition.discover?`	(`ctx`: `IntegrationContext`<`H`>, `input`: { `resume`: `null` \| `string` ; `next_page_reference`: `null` \| `string` }) => `Promise`<{ `resources`: { `id`: `string` ; `label`: `null` \| `string` }[] ; `next_page`: `null` \| `string` ; `evidence`: `string` }>	-
`definition.collections`	{ [K in string \| number \| symbol]: Object }	-
`definition.commands?`	{ [K in string \| number \| symbol]: TransportCommandDefinition<A[K], S> }	-
`definition.every?`	`SyncEvery`	SQL sources without a cadence are available for pinned inspection only. They do not schedule or admit acquisition.

Returns

{ commands: { readonly [K in string | number | symbol]: CommandHandle<ObjectType<A[K]>> } ; isIntegration: true ; discover?: (ctx: IntegrationContext<H>, input: { resume: null | string ; next_page_reference: null | string }) => Promise<{ resources: { id: string ; label: null | string }[] ; next_page: null | string ; evidence: string }> = definition.discover; invokeIntegration: (handler: (ctx: IntegrationContext<H>, …args: any[]) => unknown, argsStr: string) => Promise<string> ; [attachment]: (next: IntegrationAddress) => void ; exportIntegration: () => string } & { readonly [K in string | number | symbol]: SourceHandle<S[K]> }

definePostgresIntegration

▸ definePostgresIntegration<S>(definition): { commands: {} ; isIntegration: true ; discover?: (ctx: IntegrationContext<{}>, input: { resume: null | string ; next_page_reference: null | string }) => Promise<{ resources: { id: string ; label: null | string }[] ; next_page: null | string ; evidence: string }> = definition.discover; invokeIntegration: (handler: (ctx: IntegrationContext<{}>, …args: any[]) => unknown, argsStr: string) => Promise<string> ; [attachment]: (next: IntegrationAddress) => void ; exportIntegration: () => string } & { readonly [K in string | number | symbol]: SourceHandle<S[K]> } Read selected PostgreSQL tables through one consistent initial snapshot and atomic committed transactions. PostgreSQL installation is private.

Type parameters

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

Parameters

Name	Type
`definition`	`Object`
`definition.collections`	`S`
`definition.every?`	`SyncEvery`
`definition.freshness?`	`SyncEvery`

Returns

{ commands: {} ; isIntegration: true ; discover?: (ctx: IntegrationContext<{}>, input: { resume: null | string ; next_page_reference: null | string }) => Promise<{ resources: { id: string ; label: null | string }[] ; next_page: null | string ; evidence: string }> = definition.discover; invokeIntegration: (handler: (ctx: IntegrationContext<{}>, …args: any[]) => unknown, argsStr: string) => Promise<string> ; [attachment]: (next: IntegrationAddress) => void ; exportIntegration: () => string } & { readonly [K in string | number | symbol]: SourceHandle<S[K]> }

defineMailIntegration

▸ defineMailIntegration(definition): ReturnType<typeof defineNativeIntegration> Read mail through the integration scheduler and retained native evidence. Account, credentials and selected folders are private installation settings. Initial capture establishes a baseline; it does not manufacture arrivals. Message identity is independent of folder/label membership.

Parameters

Name	Type
`definition`	`Object`
`definition.provider`	`"imap"`
`definition.every?`	`SyncEvery`

Returns

ReturnType<typeof defineNativeIntegration>

defineOperationInterface

▸ defineOperationInterface<Args, Returns>(definition): OperationInterfaceDefinition<Infer<AsObjectValidator<Args>>, Infer<AsObjectValidator<Returns>>> Declare a targeted operation shape. Each concrete operation explicitly implements it and supplies a required target ID argument. Query this export to discover currently readable public implementations in its component.

Type parameters

Name	Type
`Args`	extends `PropertyValidators`
`Returns`	extends `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`

Parameters

Name	Type
`definition`	`Object`
`definition.name`	`string`
`definition.args`	`Args`
`definition.returns`	`Returns`

Returns

OperationInterfaceDefinition<Infer<AsObjectValidator<Args>>, Infer<AsObjectValidator<Returns>>>

operationImplementationReference

▸ operationImplementationReference<Args, Result>(implementation): OperationReference<"public", Args & { target: GenericId<string> }, Result> Bind the discovered concrete contract to an ordinary operation reference. Retain this reference with a request key for recovery; do not resolve the interface again to retry already accepted work.

Type parameters

Name	Type
`Args`	extends `DefaultFunctionArgs`
`Result`	`Result`

Parameters

Name	Type
`implementation`	`OperationImplementation`<`Args`, `Result`>

Returns

OperationReference<"public", Args & { target: GenericId<string> }, Result>

makeOperationReference

▸ makeOperationReference<Visibility, Args, LocalResult>(name, definition, functions?): Promise<OperationReference<Visibility, Args, LocalResult>> Construct a reference from a checked declaration or validator description. Types are inferred from the same description used to calculate the runtime contract. Generated references do not require this asynchronous step.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility`
`Args`	extends `DefaultFunctionArgs`
`LocalResult`	`LocalResult`

Parameters

Name	Type
`name`	`string`
`definition`	`OperationDefinition`<`Visibility`, `Args`, `LocalResult`>
`functions?`	`OperationFunctionReferences`<`Visibility`, `Args`, `LocalResult`>

Returns

Promise<OperationReference<Visibility, Args, LocalResult>> ▸ makeOperationReference<ArgsValidator, ReturnsValidator, Visibility>(name, definition, functions?): Promise<OperationReference<Visibility, Infer<AsObjectValidator<ArgsValidator>>, Infer<AsObjectValidator<ReturnsValidator>>>>

Type parameters

Name	Type
`ArgsValidator`	extends `PropertyValidators` \| `VObject`<`DefaultFunctionArgs`, `PropertyValidators`, `"required"`, `string`>
`ReturnsValidator`	extends `Validator`<`any`, `"required"`, `any`> \| `PropertyValidators`
`Visibility`	extends `FunctionVisibility` = `"public"`

Parameters

Name	Type
`name`	`string`
`definition`	`Object`
`definition.visibility?`	`Visibility`
`definition.on`	`string`
`definition.target?`	`Object`
`definition.target.argument`	`string`
`definition.interfaces?`	`OperationInterfaceContract`[]
`definition.consumes?`	`PublicationConsumption`
`definition.args`	`ArgsValidator`
`definition.returns`	`ReturnsValidator`
`functions?`	`OperationFunctionReferences`<`Visibility`, `Infer`<`AsObjectValidator`<`ArgsValidator`>>, `Infer`<`AsObjectValidator`<`ReturnsValidator`>>>

Returns

Promise<OperationReference<Visibility, Infer<AsObjectValidator<ArgsValidator>>, Infer<AsObjectValidator<ReturnsValidator>>>>

getOperationContract

▸ getOperationContract(operation): OperationContractMetadata Read the expected contract carried by an operation reference.

Parameters

Name	Type
`operation`	`OperationReference`<`any`, `any`, `any`, `undefined` \| `string`>

Returns

OperationContractMetadata

operationInvocationArgs

▸ operationInvocationArgs<Operation>(operation, request_key, args): Object Build the ordinary request envelope from the reference’s checked contract. The caller must retain the original key and arguments across uncertain outcomes.

Type parameters

Name	Type
`Operation`	extends `OperationReference`<`any`, `any`, `any`, `undefined` \| `string`>

Parameters

Name	Type
`operation`	`Operation`
`request_key`	`string`
`args`	`OperationArgs`<`Operation`>

Returns

Object

Name	Type
`request_key`	`string`
`args`	`OperationArgs`<`Operation`>
`expected_contract`	`string`

operationStatusArgs

▸ operationStatusArgs(operation, invocation_id): Object

Parameters

Name	Type
`operation`	`OperationReference`<`any`, `any`, `any`, `undefined` \| `string`>
`invocation_id`	`OperationInvocationId`

Returns

Object

Name	Type
`invocation_id`	`string`
`expected_contract`	`string`

operationPreviewArgs

▸ operationPreviewArgs<Operation>(operation, args): Object Preview uses the same business arguments and contract as invocation, without creating or consuming a business acceptance identity.

Type parameters

Name	Type
`Operation`	extends `OperationReference`<`any`, `any`, `any`, `undefined` \| `string`>

Parameters

Name	Type
`operation`	`Operation`
`args`	`OperationArgs`<`Operation`>

Returns

Object

Name	Type
`args`	`OperationArgs`<`Operation`>
`expected_contract`	`string`

apiWithOperations

▸ apiWithOperations(manifest, visibility): AnyApi Overlay analyzed operation references while retaining the inherited runtime API for every ordinary function. The generator supplies the paired types.

Parameters

Name	Type
`manifest`	`Record`<`string`, `OperationContractMetadata`>
`visibility`	`FunctionVisibility`

Returns

AnyApi

componentsWithOperations

▸ componentsWithOperations(manifest): AnyComponents Pair installed-component contracts with their explicit native export paths. Ordinary references retain the inherited component proxy behavior. Generated components objects call this; the generator supplies the paired types.

Parameters

Name	Type
`manifest`	`ComponentOperationManifest`

Returns

AnyComponents

operationFunctionReference

▸ operationFunctionReference<Visibility, Args, LocalResult, Member>(operation, member): OperationFunctionReferences<Visibility, Args, LocalResult>[Member] Resolve one companion of an operation reference to the ordinary function reference that serves it: invoke, preview and revise are mutations, recover and status are queries. Pass the result with the matching argument helper to a client or ctx.runMutation / ctx.runQuery. Explicit companion references carried by the reference are used as given; otherwise the address is derived from the operation’s own path. A component operation must carry explicit companions, and a function handle cannot name one. The reference must carry a generated contract. This only names a function: native analysis owns which companions exist, and calling one still requires its grants.

Type parameters

Name	Type
`Visibility`	extends `FunctionVisibility`
`Args`	extends `DefaultFunctionArgs`
`LocalResult`	`LocalResult`
`Member`	extends keyof `OperationFunctionReferences`<`Visibility`, `Args`, `LocalResult`>

Parameters

Name	Type
`operation`	`OperationReference`<`Visibility`, `Args`, `LocalResult`, `undefined` \| `string`>
`member`	`Member`

Returns

OperationFunctionReferences<Visibility, Args, LocalResult>[Member]

defineOperation

▸ defineOperation<ArgsValidator, ReturnsValidator>(definition): OperationDefinition<"public", OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>> Declare a public business operation. Preparation uses an ordinary mutation; native admission owns request recovery and the committed acceptance receipt.

Type parameters

Name	Type
`ArgsValidator`	extends `OperationArgsValidator`
`ReturnsValidator`	extends `OperationReturnValidator`

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.on`	`ViewDefinition`<`any`, `any`, `any`> \| `TableDefinition`<`any`, `any`, `any`, `any`, `false`>	-
`definition.target?`	`Object`	Explicit selected-object argument; discovery never guesses from names.
`definition.target.argument`	`string`	-
`definition.implements?`	readonly `OperationInterfaceDefinition`<`any`, `any`>[]	-
`definition.consumes?`	`PublicationConsumption`	-
`definition.args`	`ArgsValidator`	-
`definition.returns`	`ReturnsValidator`	Defines the public local result type and validates preparation, independently of a particular handler’s narrower result or any remote outcome.
`definition.prepare`	(`ctx`: `BijectionMutationCtx`<`any`>, `args`: `OperationArgsFromValidator`<`ArgsValidator`>) => `ReturnValueForOptionalValidator`<`ReturnsValidator`>	-

Returns

OperationDefinition<"public", OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>>

defineInternalOperation

▸ defineInternalOperation<ArgsValidator, ReturnsValidator>(definition): OperationDefinition<"internal", OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>> Declare an operation callable only from authorized server execution. Internal visibility does not grant permission to its effects.

Type parameters

Name	Type
`ArgsValidator`	extends `OperationArgsValidator`
`ReturnsValidator`	extends `OperationReturnValidator`

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.on`	`ViewDefinition`<`any`, `any`, `any`> \| `TableDefinition`<`any`, `any`, `any`, `any`, `false`>	-
`definition.target?`	`Object`	Explicit selected-object argument; discovery never guesses from names.
`definition.target.argument`	`string`	-
`definition.implements?`	readonly `OperationInterfaceDefinition`<`any`, `any`>[]	-
`definition.consumes?`	`PublicationConsumption`	-
`definition.args`	`ArgsValidator`	-
`definition.returns`	`ReturnsValidator`	Defines the public local result type and validates preparation, independently of a particular handler’s narrower result or any remote outcome.
`definition.prepare`	(`ctx`: `BijectionMutationCtx`<`any`>, `args`: `OperationArgsFromValidator`<`ArgsValidator`>) => `ReturnValueForOptionalValidator`<`ReturnsValidator`>	-

Returns

OperationDefinition<"internal", OperationArgsFromValidator<ArgsValidator>, Infer<AsObjectValidator<ReturnsValidator>>>

paginationResultValidator

▸ paginationResultValidator<T>(itemValidator): VObject<{ splitCursor: undefined | null | string ; pageStatus: undefined | null | "SplitRecommended" | "SplitRequired" ; page: T["type"][] ; continueCursor: string ; isDone: boolean }, { page: VArray<T["type"][], T, "required"> ; continueCursor: VString<string, "required"> ; isDone: VBoolean<boolean, "required"> ; splitCursor: VUnion<undefined | null | string, [VString<string, "required">, VNull<null, "required">], "optional", never> ; pageStatus: VUnion<undefined | null | "SplitRecommended" | "SplitRequired", [VLiteral<"SplitRecommended", "required">, VLiteral<"SplitRequired", "required">, VNull<null, "required">], "optional", never> }, "required", "page" | "continueCursor" | "isDone" | "splitCursor" | "pageStatus"> A Validator factory for PaginationResult. Create a validator for the result of calling paginate with a given item validator. For example:

const paginationResultValidator = paginationResultValidator(v.object({
  _id: v.id("users"),
  _creationTime: v.number(),
  name: v.string(),
}));

Type parameters

Name	Type
`T`	extends `Validator`<`Value`, `"required"`, `string`>

Parameters

Name	Type	Description
`itemValidator`	`T`	A validator for the items in the page

Returns

VObject<{ splitCursor: undefined | null | string ; pageStatus: undefined | null | "SplitRecommended" | "SplitRequired" ; page: T["type"][] ; continueCursor: string ; isDone: boolean }, { page: VArray<T["type"][], T, "required"> ; continueCursor: VString<string, "required"> ; isDone: VBoolean<boolean, "required"> ; splitCursor: VUnion<undefined | null | string, [VString<string, "required">, VNull<null, "required">], "optional", never> ; pageStatus: VUnion<undefined | null | "SplitRecommended" | "SplitRequired", [VLiteral<"SplitRecommended", "required">, VLiteral<"SplitRequired", "required">, VNull<null, "required">], "optional", never> }, "required", "page" | "continueCursor" | "isDone" | "splitCursor" | "pageStatus"> A validator for the pagination result

definePublished

▸ definePublished<Row>(definition): PublishedDefinition<Row> Declare a table whose rows one producer publishes.

Type parameters

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

Parameters

Name	Type
`definition`	`Object`
`definition.producer`	`string`
`definition.member`	`string`
`definition.row`	`Row`

Returns

PublishedDefinition<Row> ▸ definePublished<Row>(definition): PublishedDefinition<VObject<ObjectType<Row>, Row>> Declare a table whose rows one producer publishes.

Type parameters

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

Parameters

Name	Type
`definition`	`Object`
`definition.producer`	`string`
`definition.member`	`string`
`definition.row`	`Row`

Returns

PublishedDefinition<VObject<ObjectType<Row>, Row>>

definePublisher

▸ definePublisher(definition): PublisherDefinition Declare a publisher over this deployment’s own functions.

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.producer`	`string`	Explicit output group producer, used to reserve ownership at deploy.
`definition.manifest`	`string` \| `FunctionReference`<`"query"`, `"internal"`, `any`, `any`>	An internal query answering which runs are ready to publish.
`definition.steps`	`string` \| `FunctionReference`<`"query"`, `"internal"`, `any`, `any`>	An internal query paging one ready run’s sealed step records.
`definition.page`	`string` \| `FunctionReference`<`"query"`, `"internal"`, `any`, `any`>	An internal query paging one output member’s staged rows.
`definition.rebuild`	`string` \| `FunctionReference`<`"mutation"`, `"internal"`, `any`, `any`>	Called once after a deployment reserves a new owner epoch. It records authored rebuild intent through the ordinary mutation path.
`definition.transition?`	`PublisherTransition`	Required when moving, changing membership, or retiring a published group.

Returns

PublisherDefinition

decideEach

▸ decideEach<R>(requests, decide): Promise<ReadAccessResults> Decide each request of a batch on its own, in order. A return inside decide settles only its own request; a throw refuses the batch.

Type parameters

Name
`R`

Parameters

Name	Type
`requests`	readonly `R`[]
`decide`	(`request`: `R`) => `ReadAccessResult` \| `Promise`<`ReadAccessResult`>

Returns

Promise<ReadAccessResults>

httpRouter

▸ httpRouter(): HttpRouter Return a new HttpRouter object.

Returns

HttpRouter

defineTable

▸ defineTable<DocumentSchema>(documentSchema): TableDefinition<DocumentSchema> Define a table in a schema. You can either specify the schema of your documents as an object like

defineTable({
  field: v.string()
});

or as a schema type like

defineTable(
 v.union(
   v.object({...}),
   v.object({...})
 )
);

Type parameters

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

Parameters

Name	Type	Description
`documentSchema`	`DocumentSchema`	The type of documents stored in this table.

Returns

TableDefinition<DocumentSchema> A TableDefinition for the table. ▸ defineTable<DocumentSchema>(documentSchema): TableDefinition<VObject<ObjectType<DocumentSchema>, DocumentSchema>> Define a table in a schema. You can either specify the schema of your documents as an object like

defineTable({
  field: v.string()
});

or as a schema type like

defineTable(
 v.union(
   v.object({...}),
   v.object({...})
 )
);

Type parameters

Name	Type
`DocumentSchema`	extends `Record`<`string`, `GenericValidator`>

Parameters

Name	Type	Description
`documentSchema`	`DocumentSchema`	The type of documents stored in this table.

Returns

TableDefinition<VObject<ObjectType<DocumentSchema>, DocumentSchema>> A TableDefinition for the table.

docValidator

▸ docValidator<TableName, Table>(tableName, table): DocValidator<TableName, Table["validator"]> Build the validator for whole documents of a table, by adding the _id and _creationTime system fields to the table’s own validator. Prefer doc when you have the schema in hand: it checks the table name against the schema. Example

const messageDoc = docValidator("messages", schema.tables.messages);

export const get = query({
  args: { id: v.id("messages") },
  returns: v.union(messageDoc, v.null()),
  handler: (ctx, args) => ctx.db.get(args.id),
});

Type parameters

Name	Type
`TableName`	extends `string`
`Table`	extends `TableDefinition`<`any`, `any`, `any`, `any`, `boolean`, `Table`>

Parameters

Name	Type	Description
`tableName`	`TableName`	The name of the table, used for the `_id` validator.
`table`	`Table`	The TableDefinition for that table.

Returns

DocValidator<TableName, Table["validator"]> A validator matching documents of the table.

defineSchema

▸ defineSchema<Schema, StrictTableNameTypes>(schema, options?): SchemaDefinition<Schema, StrictTableNameTypes> Define the schema of this Bijection project. This should be exported as the default export from a schema.ts file in your bijection/ directory. The schema enables runtime validation of documents and provides end-to-end TypeScript type safety. Every document in Bijection automatically has two system fields:

_id - a unique document ID with validator v.id("tableName")
_creationTime - a creation timestamp with validator v.number()

You do not need to include these in your schema definition, they are added automatically. Example

// bijection/schema.ts
import { defineSchema, defineTable } from "bijection/server";
import { v } from "bijection/values";

export default defineSchema({
  users: defineTable({
    name: v.string(),
    email: v.string(),
  }).index("by_email", ["email"]),

  messages: defineTable({
    body: v.string(),
    userId: v.id("users"),
    channelId: v.id("channels"),
  }).index("by_channel", ["channelId"]),

  channels: defineTable({
    name: v.string(),
  }),

  // Discriminated union table:
  results: defineTable(
    v.union(
      v.object({ kind: v.literal("error"), message: v.string() }),
      v.object({ kind: v.literal("success"), value: v.number() }),
    )
  ),
});

Best practice: Always include all index fields in the index name. For example, an index on ["field1", "field2"] should be named "by_field1_field2". See https://docs.bijection.com/database/schemas

Type parameters

Name	Type
`Schema`	extends `GenericSchema`
`StrictTableNameTypes`	extends `boolean` = `true`

Parameters

Name	Type	Description
`schema`	`Schema` & `ViewInputsInSchema`<`Schema`>	A map from table name to TableDefinition for all of the tables in this project.
`options?`	`DefineSchemaOptions`<`StrictTableNameTypes`>	Optional configuration. See DefineSchemaOptions for a full description.

Returns

SchemaDefinition<Schema, StrictTableNameTypes> The schema.

getTableChangeToken

▸ getTableChangeToken(table): Promise<string> Observe committed changes anywhere in a table, including deletions and updates outside a sampled page. The opaque token is not source provenance. Current table access applies, and this read is reactive without scanning rows.

Parameters

Name	Type
`table`	`string`

Returns

Promise<string>

defineView

▸ defineView<From, Plan>(definition): ViewDefinition<From, Plan>

Type parameters

Name	Type
`From`	extends `string`
`Plan`	`Plan`

Parameters

Name	Type
`definition`	`Object`
`definition.key`	`ViewKey`<`From`>
`definition.expression`	`ViewQuery`<`Plan`>
`definition.limits?`	`ViewLimits`

Returns

ViewDefinition<From, Plan>

defineWait

▸ defineWait(definition): WaitDefinition Declare a durable wait over this deployment’s own functions.

Parameters

Name	Type	Description
`definition`	`Object`	-
`definition.keys?`	`string` \| `FunctionReference`<`"query"`, `"internal"`, `any`, `any`>	An internal query listing at most 32 stable instance keys. Each key’s `due` runs in its own transaction; `due` and `then` receive `{ key }`.
`definition.due`	`string` \| `FunctionReference`<`"query"`, `"internal"`, `any`, `any`>	An internal query returning the next boundary in epoch milliseconds, or `null` when the program has no next boundary for this concern.
`definition.then`	`string` \| `FunctionReference`<`"mutation"`, `"internal"`, `any`, `any`>	An internal mutation the engine schedules when the boundary is reached.

Returns

WaitDefinition

​Usage

​Code Generation

​Example

​Classes

​Interfaces

​References

​UserIdentityAttributes

​Type Aliases

​FunctionType

​FunctionReference

​Type parameters

​Type declaration

​FunctionReference_future

​Type parameters

​Type declaration

​ApiFromModules

​Type parameters

​FilterApi

​Type parameters

​AnyApi

​PartialApi

​Type parameters

​FunctionArgs

​Type parameters

​OptionalRestArgs

​Type parameters

​ArgsAndOptions

​Type parameters

​FunctionReturnType

​Type parameters

​ValidatorTypeToReturnType

​Type parameters

​ApplicationSourceControl

​Type declaration

Parameters

Returns

​CollectionNotificationKind

​Type declaration

​AppNoticeContent

​Type declaration

​ResolvedNotificationKind

​Type declaration

​ApplicationNotificationKind

​ApplicationNotifications

​Type declaration

​ApplicationPeople

​Type declaration

​AppPlace

​Type declaration

​AppPlaceSearch

​ApplicationPlaces

​Type declaration

​ApplicationMapValues

​AppSpatialBound

​Type declaration

​AppSpatialIndex

​Type declaration

​AppSpatialIndexes

​AuditLogBody

​Index signature

​AuditLogValue

​AuthConfig

​Type declaration

​AuthProvider

​FunctionHandle

​Type parameters

​ComponentDefinition

​Type parameters

​Type declaration

​EnvDefinition

​EnvFromDefinition

​Type parameters

​EnvFromAppDefinition

​Type parameters

​AppDefinition

​Type parameters

​Type declaration

​AnyChildComponents

​AnyComponents

​UploadCompletionReference

Usage

Code Generation

Example

Classes

Interfaces

References

UserIdentityAttributes

Type Aliases

FunctionType

FunctionReference

Type parameters

Type declaration

FunctionReference_future

Type parameters

Type declaration

ApiFromModules

Type parameters

FilterApi

Type parameters

AnyApi

PartialApi

Type parameters

FunctionArgs

Type parameters

OptionalRestArgs

Type parameters

ArgsAndOptions

Type parameters

FunctionReturnType

Type parameters

ValidatorTypeToReturnType

Type parameters

ApplicationSourceControl

Type declaration

CollectionNotificationKind

Type declaration

AppNoticeContent

Type declaration

ResolvedNotificationKind

Type declaration

ApplicationNotificationKind

ApplicationNotifications

Type declaration

ApplicationPeople

Type declaration

AppPlace

Type declaration

AppPlaceSearch

ApplicationPlaces

Type declaration

ApplicationMapValues

AppSpatialBound

Type declaration

AppSpatialIndex

Type declaration

AppSpatialIndexes

AuditLogBody

Index signature

AuditLogValue

AuthConfig

Type declaration

AuthProvider

FunctionHandle

Type parameters

ComponentDefinition

Type parameters

Type declaration

EnvDefinition

EnvFromDefinition

Type parameters

EnvFromAppDefinition

Type parameters

AppDefinition

Type parameters

Type declaration

AnyChildComponents

AnyComponents

UploadCompletionReference

BijectionQueryBuilder

Type parameters