Module: apps - Bijection

Classes

DataReleaseError

References

SourceStatus

Type Aliases

ArgumentIssueCode

ArgumentValueIssue

Ƭ ArgumentValueIssue: Object

Type declaration

Name	Type
`path`	`string`[]
`code`	`ArgumentIssueCode`
`message`	`string`

AppBoardField

Ƭ AppBoardField: Object A board uses a closed set of at most sixteen text categories. Counts and cards are the current page’s, never a second query or a global total.

Type declaration

Name	Type
`name`	`string`
`label`	`string`
`values`	`string`[]

AppBoundRefusal

Ƭ AppBoundRefusal: Object A refusal of a request past a stated bound. bound names it (see the module note), limit is the enforced value in the bound’s own unit.

Type declaration

Name	Type
`code`	`"bound_exceeded"`
`bound`	`string`
`limit`	`number`
`message`	`string`
`retryable`	`false`

AppInvalidRequest

Ƭ AppInvalidRequest: Object A request the contract does not take as given (a malformed or unsupported clause): retrying it unchanged fails again.

Type declaration

Name	Type
`code`	`"invalid_request"`
`message`	`string`
`retryable`	`false`

AppCadence

Ƭ AppCadence: { kind: "every" ; minutes: number ; anchor: number } | { kind: "daily" ; at: string } | { kind: "weekly" ; weekday: 1 | 2 | 3 | 4 | 5 | 6 | 7 ; at: string } | { kind: "monthly" ; day: number | "last" ; at: string } When a standing time trigger fires.

every: every minutes (an integer, at least 1) minutes, on the boundaries anchor + k × minutes (anchor in exact epoch milliseconds); no calendar or time zone applies.
daily: every day at at (HH:MM, 24-hour) in the schedule’s time zone.
weekly: every week on weekday (Monday is 1, Sunday 7) at at.
monthly: every month on day (1 to 28) or on its last day (last), at at.

A wall-clock time the zone skips (a daylight-saving gap) fires at the first minute after the gap; one it repeats fires at the earlier instant only.

AppComments

Ƭ AppComments: Object A collection’s discussion, presented on its object page’s Comments tab.

Type declaration

Name	Type	Description
`relation`	`string`	An incoming relation of the object: the comment collection’s reference to it, read through the relation’s own index. With `thread`, it holds the thread starts only.
`bodyProperty`	`string`	The comment’s text, Markdown with mention tokens.
`messageArgument`	`string`	The post operation’s (and the edit operation’s) text argument.
`authorProperty`	`string`	The comment’s author: with `mentions`, a reference to a person.
`dateProperty`	`string`	When the comment was posted.
`operation`	`string`	The declared operation that posts a comment on this object.
`preset`	`Record`<`string`, `string`>	Fixed arguments of the post operation.
`thread?`	{ `repliesRelation`: `string` ; `parentArgument`: `string` ; `replyCountProperty`: `string` }	One level of replies: `repliesRelation` is a relation of the comment collection to itself (replies by their parent), `parentArgument` the post operation’s optional reference to the comment replied to, and `replyCountProperty` the number of replies the program keeps on a thread start.
`thread.repliesRelation`	`string`	-
`thread.parentArgument`	`string`	-
`thread.replyCountProperty`	`string`	-
`mentions?`	`true`	Bodies may mention the application’s people: the application declares people (the application builder refuses mentions without them), and the author is one of them.
`edit?`	{ `operation`: `string` ; `messageArgument`: `string` ; `editedProperty`: `string` }	The author edits their own comment through this operation, which targets the comment; `editedProperty` holds when it was last edited.
`edit.operation`	`string`	-
`edit.messageArgument`	`string`	-
`edit.editedProperty`	`string`	-

AppCommentsPlan

Ƭ AppCommentsPlan: Object What a checked declaration resolves to.

Type declaration

Name	Type	Description
`collection`	`AppCollection`	The comment collection.
`replies`	`string` \| `null`	The relation of the comment collection that reads a thread’s replies, when replies are declared.

AppCanonicalMentions

Ƭ AppCanonicalMentions: { text: string ; ids: string[] } | { refusal: string } The stored form of a comment body, or why it is refused.

AppCursor

Ƭ AppCursor: { kind: "native" ; cursor: string } | { kind: "index" ; cursor: string } | { kind: "walk" ; cursor: string } | { kind: "key" ; key: (Value | undefined)[] } | { kind: "series" ; cursor: string } An application page’s position. Opaque to clients.

AppPageRestart

Ƭ AppPageRestart: Object The refusal of a page whose cursor no longer continues its pages: a region listed whole that has since grown past one read, an ordering or readable partition set that changed, or an inherited cursor the engine no longer accepts. It is a BijectionError with this data; paginationError is the inherited paginated-query signal (usePaginatedQuery starts again from the first page on it), and a client holding its own cursors does the same (isAppPageRestart).

Type declaration

Name	Type
`code`	`"page_restart"`
`paginationError`	`"InvalidCursor"`
`message`	`string`

DataReleaseDefinition

Ƭ DataReleaseDefinition: Object The exact positive output contract reviewed by the source’s release authority.

Type declaration

Name	Type	Description
`is_standing`	`boolean`	Reusable approval; every execution rechecks grants, code and expiry.
`component`	`string` \| `null`	-
`query`	`string`	-
`arguments`	`string`	-
`destination_table`	`string`	-
`rows`	`string`[]	-
`fields`	`string`[]	-

DataReleaseSource

Ƭ DataReleaseSource: Object A logical source requirement; root relations omit the component.

Type declaration

Name	Type
`component`	`string` \| `null`
`table`	`string`

DataReleaseContainer

Ƭ DataReleaseContainer: DataReleaseSource & { field: string ; key: string } An explicitly named registered container.

DataReleaseReceipt

Ƭ DataReleaseReceipt: Object Immutable acceptance identity. A lost response can recover the same epoch by executing the same request and approval IDs.

Type declaration

Name	Type
`epoch`	`string`

ReleaseAccessSimulation

Ƭ ReleaseAccessSimulation: Object Content-free comparison under the actual current read owner. Removing selected source requirements here changes no state and approves no output. The container’s own read policy remains in both comparisons.

Type declaration

Name	Type
`containers`	{ `container`: `DataReleaseContainer` ; `requirements`: `DataReleaseSource`[] ; `readers`: { `reader`: `Record`<`string`, `unknown`> ; `is_readable`: `boolean` ; `is_readable_without_selected_requirements`: `boolean` ; `refused_requirements`: `DataReleaseSource`[] }[] }[]

ResourceRef

Ƭ ResourceRef: `

\{"collection" \| "operation" \| "function" \| "relation" \| "interface"}:

{string}` Deployment-relative identity. Copy it from discovery; names are case-sensitive.

ResourceKind

DiscoverySummary

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

Type declaration

Name	Type
`ref`	`ResourceRef`
`kind`	`ResourceKind`
`collectionKind?`	`AppCollection`[`"kind"`]
`modality?`	`"native_series"`
`name`	`string`
`label?`	`string`
`description?`	`string`
`on?`	`ResourceRef`

DiscoverArgs

Ƭ DiscoverArgs: Object

Type declaration

Name	Type
`search?`	`string`
`kind?`	`ResourceKind`
`relatedTo?`	`ResourceRef`
`limit?`	`number`
`cursor?`	`string`

DiscoveryPage

Ƭ DiscoveryPage: Object

Type declaration

Name	Type
`apiVersion`	`1`
`basis`	`string`
`items`	`DiscoverySummary`[]
`next_cursor`	`string` \| `null`

DiscoveredFunction

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

Type declaration

Name	Type
`name`	`string`
`functionType`	`"query"` \| `"mutation"` \| `"action"`
`args_json`	`string` \| `null`
`returns_json`	`string` \| `null`
`question?`	{ `args_json`: `string` ; `outputs`: `QuestionOutputContracts` ; `binding`: `QuestionBinding` } \| `null`

OperationCompanion

Ƭ OperationCompanion: typeof operationCompanionNames[number]

ResourceSummary

Ƭ ResourceSummary<K>: Omit<DiscoverySummary, "kind" | "ref"> & { kind: K ; ref: `

\{K}:

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

Type parameters

Name	Type
`K`	extends `ResourceKind`

SeriesReader

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

Type declaration

Name	Type
`function`	`function:${string}`
`args`	{ `collection`: `string` }
`args.collection`	`string`

DiscoveryResource

Ƭ DiscoveryResource: ResourceSummary<"collection"> & { collectionKind: AppCollection["kind"] ; relationContract?: RelationDescriptor ; fileFields: NonNullable<AppCollection["file_fields"]> ; component?: string ; validator_json: string ; identity: { field: "_id" ; table: string } | { field: "event_key" ; occurrence: ["series_id", "source", "event_id"] } | null ; native_series?: SeriesMetadata ; series_properties?: Record<string, AppSeriesProperty & { time: { unit: "microsecond" ; range: "half_open" ; representation: "int64" } ; read?: { function: "function:application:seriesProperty" ; args: { collection: string ; property: string } ; kinds: AppSeriesProperty["reads"] } ; prepare?: { function: "function:application:seriesPropertyPrepare" ; args: { collection: string ; property: string } ; kinds: AppSeriesProperty["preparations"] } ; analysis?: { function: "function:application:seriesPropertyAnalysis" ; args: Record<string, never> } }> ; time?: { unit: "microsecond" ; range: "half_open" ; representation: "int64" } ; correction?: "greatest_order" ; coverage?: "retained_accepted_data" ; titleProperty?: string ; indexes: AppCollection["indexes"] ; searchIndexes: AppCollection["search_indexes"] ; readCost: AppCollection["read_cost"] ; query: Pick<AppPresentation, "sortIndexes" | "search" | "dimensions" | "dateDimensions" | "numericDimensions" | "measures"> ; valueMeaning: Record<string, Pick<NonNullable<AppPresentation["properties"]>[string], "format" | "point" | "cell" | "scale" | "currency">> ; relations: ResourceRef[] ; operations: ResourceRef[] ; reads: { seriesEvents?: SeriesReader & { maxPageSize: number ; defaultPageSize: number } ; seriesSamples?: SeriesReader & { maxPageSize: number ; defaultPageSize: number } ; seriesSummary?: SeriesReader ; seriesWindows?: SeriesReader ; seriesErasure?: SeriesReader ; questions?: { ask: `function:

\{string}\` ; `status`: \`function:

{string}` ; page: `function:

\{string}\` ; `facets`: \`function:

{string}` ; close: `function:

\{string}\` ; `observe`: \`function:

{string}` ; explain: `function:

\{string}\` ; `args`: \{ `collection`: `string` \} \} ; `browse?`: \{ `function`: \`function:

{string}` ; args: { collection: string } ; maxPageSize: number } ; get?: { function: `function:

\{string}\` ; `args`: \{ `collection`: `string` \} \} \} \} \| [`ResourceSummary`](/api/modules/apps#resourcesummary)\<``"operation"``\> & \{ `access`: [`apps`](/api/modules/apps) ; `contract_json`: `string` ; `contract_digest`: `string` ; `pipeline_operation?`: `string` ; `pipeline_keys?`: `string`[] ; `pipeline_observer?`: \{ `kind`: ``"native"`` ; `query`: `string` \} \| \{ `kind`: ``"external"`` ; `query`: `string` ; `publication_query`: `string` ; `wait_query`: `string` ; `cancel_wait`: `string` \} ; `component?`: `string` ; `forwarder?`: `string` ; `calls`: `Record`\<[`OperationCompanion`](/api/modules/apps#operationcompanion), `string`\> ; `argument_queries`: `Record`\<`string`, \{ `function`: \`function:

{string}` ; collection: `collection:

\{string}\` ; `requires`: `string`[] ; `meaning`: ``"suggestions"`` \}\> ; `datasetSave?`: \{ `datasets`: `string`[] ; `reservation`: `string` ; `preparation`: `string` ; `publication`: `string` \} ; `authorization`: ``"checkedOnEveryCall"`` ; `execution`: \{ `expectedContract`: ``"required"`` ; `requestKey`: ``"reuseAfterUnknownOutcome"`` ; `preview`: ``"doesNotAcceptOrReserve"`` \} \} \| [`ResourceSummary`](/api/modules/apps#resourcesummary)\<``"function"``\> & [`DiscoveredFunction`](/api/modules/apps#discoveredfunction) & \{ `authorization`: ``"checkedOnEveryCall"`` \} \| `Omit`\<[`ResourceSummary`](/api/modules/apps#resourcesummary)\<``"function"``\>, ``"kind"``\> & [`DiscoveredFunction`](/api/modules/apps#discoveredfunction) & \{ `kind`: ``"question"`` ; `question`: `NonNullable`\<[`DiscoveredFunction`](/api/modules/apps#discoveredfunction)[``"question"``]\> ; `authorization`: ``"checkedOnEveryCall"`` \} \| [`ResourceSummary`](/api/modules/apps#resourcesummary)\<``"relation"``\> & \{ `from`: \`collection:

{string}` ; to: `collection:

\{string}\` ; `cardinality`: \{ `min`: `number` ; `max`: `number` \| ``null`` \} ; `orderBy`: `string`[] ; `read?`: \{ `function`: \`function:

{string}` ; args: { collection: string ; relation: string } ; from: { collection: `collection:

\{string}\` ; `property`: ``"_id"`` \} \} \} \| [`ResourceSummary`](/api/modules/apps#resourcesummary)\<``"interface"``\> & \{ `contract_json`: `string` ; `implementations`: \`operation:

{string}`[] } A static contract. Dynamic suggestions are ordinary, separately called queries.

DiscoveryDescription

Ƭ DiscoveryDescription: { apiVersion: 1 ; basis: string } & DiscoveryResource

ArgumentChoicesArgs

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

Type declaration

Name	Type
`operation`	`ResourceRef`
`argument`	`string`
`args`	`Record`<`string`, `Value`>
`expected_contract`	`string`
`paginationOpts`	{ `numItems`: `number` ; `cursor`: `string` \| `null` }
`paginationOpts.numItems`	`number`
`paginationOpts.cursor`	`string` \| `null`
`search?`	`string`

ArgumentChoicesPage

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

Type declaration

Name	Type
`items`	{ `value`: `string` ; `label`: `string` }[]
`next_cursor`	`string` \| `null`
`end`	`AppPageEnd`

AppObjectFile

Ƭ AppObjectFile: Object One object’s file as objectFiles answers it: the file as the storage owner records it, the locator delivery reads it through (client.files.download(locator)), the collection’s native component address (absent at the app root; it is not permission), and the name the object gives it (its declared name property), or null.

Type declaration

Name	Type
`file`	`FileInfo`
`locator`	`AttachmentLocator`
`component?`	`string`
`name`	`string` \| `null`

AppGeometryType

Ƭ AppGeometryType: typeof APP_GEOMETRY_TYPES[number]

AppGeometryProfile

Ƭ AppGeometryProfile: typeof APP_GEOMETRY_PROFILES[number]

AppGeometrySize

Ƭ AppGeometrySize: typeof APP_GEOMETRY_SIZES[number]

AppGeometryDeclaration

Ƭ AppGeometryDeclaration: Object A geometry property’s declared profile and size tier: what the engine admits its values under.

Type declaration

Name	Type
`profile`	`AppGeometryProfile`
`size`	`AppGeometrySize`

AppSpatialField

Ƭ AppSpatialField: AppGeometryDeclaration & { types: AppGeometryType[] ; is_nullable: boolean ; is_position: boolean } One spatial field resolved by native schema admission.

AppRegion

Ƭ AppRegion: { kind: "box" ; west: number ; south: number ; east: number ; north: number } | { kind: "distance" ; center: { type: "Point" ; coordinates: number[] } ; radiusMetres: number } | { kind: "polygon" ; area: { type: "Polygon" ; coordinates: number[][][] } | { type: "MultiPolygon" ; coordinates: number[][][][] } } | { kind: "point" ; point: { type: "Point" ; coordinates: number[] } } | { kind: "line" ; line: { type: "LineString" ; coordinates: number[][] } | { type: "MultiLineString" ; coordinates: number[][][] } } | { kind: "object" ; collection: string ; id: string ; field: string } A region a map draws, as the application query contract carries it. It has a semantic shape that the native workspace adapter translates into typed spatial expressions.

box: closed on every side; west > east crosses the antimeridian.
distance: every point within radiusMetres great-circle metres of center on the geometry profile’s sphere.
polygon: a closed WGS84 [longitude, latitude] polygon.
point: one WGS84 point, as a query geometry of a shape property (the shapes that contain it, say).
line: a WGS84 LineString or MultiLineString, as a query geometry of a shape property (the shapes a route crosses, say).
object: the stored value of field, a declared geometry property of one object (id) of an exposed collection (collection): referenced, never copied. The backend reads that object with the caller’s ordinary point read (getMany), so the read joins the query’s read set and an edit to the shape reruns the query; a missing object, one the caller may not read, or one without a value refuses the clause (AppRegionRefusal). Its value resolves to a polygon (Polygon or MultiPolygon), a point or a line, as the property holds it, up to the geometry profile’s large tier (which its declaration admitted when it was written); the spatial index’s exact-work bound still applies.

A point property takes distance, box, polygon and an object holding an area; a shape property takes box, polygon, point, line and object.

AppRegionRefusal

Ƭ AppRegionRefusal: Object The refusal of a spatial clause whose object region cannot be resolved: absent (no such object), restricted (the caller’s read of it was refused), empty (the object holds no value of the property) or kind (its value is not a region this property takes: a point property takes an area only, and a MultiPoint is no region). It is a BijectionError with this data (isAppRegionRefusal).

Type declaration

Name	Type
`regionRefused`	`"absent"` \| `"restricted"` \| `"empty"` \| `"kind"`
`message`	`string`

AppSpatialMode

Ƭ AppSpatialMode: typeof APP_SPATIAL_MODES[number]

AppWithin

Ƭ AppWithin: Object A region applied to one geometry property by mode (default intersects).

Type declaration

Name	Type
`field`	`string`
`region`	`AppRegion`
`mode?`	`AppSpatialMode`

AppNearest

Ƭ AppNearest: Object The k objects whose point property lies nearest center, by great-circle distance on the geometry profile’s sphere, ties by id, among the objects the view’s other clauses admit; at most maxMetres away when given. Objects without a located value are never ranked. center is a [longitude, latitude] pair (its argument validator is an array of two numbers, checked by appNearestError).

Type declaration

Name	Type
`field`	`string`
`center`	`number`[]
`k`	`number`
`maxMetres?`	`number`

AppCellGrouping

Ƭ AppCellGrouping: Object Group a point property by the cell of a discrete global grid that holds each object’s value (AppSummaryArgs.cells).

Type declaration

Name	Type
`system`	keyof typeof `APP_CELL_SYSTEMS`
`resolution`	`number`

AppRegionKind

Ƭ AppRegionKind: AppRegion["kind"]

AppSpatialIndexInfo

Ƭ AppSpatialIndexInfo: Object One declared geometry property whose spatial clauses the application answers in its queries, through the spatial index the program registers (defineApplication({ spatialIndexes })): the AppSpatialModes and region kinds it takes (a shape property takes no distance), whether it ranks nearest objects, and the grid systems its summary groups it by (a point property; none for shapes). Reported by the application.

Type declaration

Name	Type	Description
`field`	`string`	-
`access_path?`	{ `index`: `string` ; `partition_by`: `string`[] }	The schema-fixed native path, when the index is native.
`access_path.index`	`string`	-
`access_path.partition_by`	`string`[]	-
`modes`	`AppSpatialMode`[]	-
`regions`	`AppRegionKind`[]	-
`nearest`	`boolean`	-
`cells`	`AppCellSystem`[]	-

AppMapView

Ƭ AppMapView: Object What a map view of a collection remembers. Presentation only:

field: the declared geometry property drawn; when absent, the collection’s defaultMapField, else its first in name order.
center and zoom: the saved viewport; absent fits the loaded objects.
aggregate: draw the whole query scope counted per grid cell (a cell summary, AppSummaryArgs.cells) instead of the loaded objects: as count bubbles (clusters), a hexagon grid coloured by count (grid) or a heatmap of cell centres weighted by count (heatmap). Only for a point property with a spatial index.

Type declaration

Name	Type
`field?`	`string`
`center?`	[`number`, `number`]
`zoom?`	`number`
`aggregate?`	`AppMapAggregate`

AppMapAggregate

Ƭ AppMapAggregate: "clusters" | "grid" | "heatmap" How a map aggregates a point property (aggregate).

AppCellSystem

Ƭ AppCellSystem: keyof typeof APP_CELL_SYSTEMS A discrete global grid (APP_CELL_SYSTEMS).

AppPointSource

Ƭ AppPointSource: { kind: "value" } | { kind: "position" } | { kind: "point" ; longitude: string ; latitude: string } Where a point comes from: the property itself, or two numeric properties.

AppGeometrySource

Ƭ AppGeometrySource: AppPointSource | { kind: "cell" ; system: AppCellSystem ; of?: string ; parent?: string } | { kind: "line" ; from: string ; to: string ; ends: [AppPointSource, AppPointSource] } Where a geometry field’s value comes from: the property itself, a point built from two numeric properties, a stored grid cell id whose boundary the client derives (render-only, never a spatial index), or a line from one declared point field to another of the same object (render-only, never a spatial index: its ends’ own indexes and filters apply). A cell’s of, when declared, names the geometry field whose cell it stores (a point’s cell, or a shape’s canonical geohash cell), and its parent the coarser stored cell of the same field holding it. A line’s ends are the sources of its from and to point fields.

AppGeometryField

Ƭ AppGeometryField: Object One declared geometry field of a collection.

Type declaration

Name	Type	Description
`name`	`string`	The property name, or a derived point’s declared name.
`label`	`string`	-
`types`	`AppGeometryType`[]	-
`profile`	`AppGeometryProfile`	The declared profile: a property’s own declaration; a derived point, line or cell is 2D.
`size`	`AppGeometrySize`	The declared size tier; derived fields are standard.
`source`	`AppGeometrySource`	-

GeometryDeclarations

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

Type declaration

Name	Type
`validator_json`	`string`
`spatial_fields?`	`Record`<`string`, `AppSpatialField`>
`indexes?`	readonly { `spatial?`: { `field`: `string` } }[]
`properties?`	`Record`<`string`, { `label?`: `string` ; `format?`: `string` ; `point?`: { `longitude`: `string` ; `latitude`: `string` } ; `line?`: { `from`: `string` ; `to`: `string` } ; `cell?`: { `of`: `string` ; `parent?`: `string` } }>

AppGeometry

Ƭ AppGeometry: { type: "Point" ; coordinates: [number, number] } | { type: "MultiPoint" | "LineString" ; coordinates: [number, number][] } | { type: "MultiLineString" | "Polygon" ; coordinates: [number, number][][] } | { type: "MultiPolygon" ; coordinates: [number, number][][][] } A GeoJSON geometry value as the workspace reads it.

AppBox

Ƭ AppBox: Object A box of WGS84 degrees, west <= east.

Type declaration

Name	Type
`west`	`number`
`south`	`number`
`east`	`number`
`north`	`number`

AppGraphPropertyKind

Ƭ AppGraphPropertyKind: "category" | "number" | "time" How a property can present a node: by its distinct values, along a numeric range, or on a time axis.

AppGraphTypeStyle

Ƭ AppGraphTypeStyle: [type: number, colour: number, label: number, badges: number[], time: number] One node type’s style in a saved graph: [type, colour, label, badges, time], indexes into AppGraph.types and AppGraph.fields, -1 for none. type is a node type; the entries are sorted by it, one per type at most, and an entry sets at least one of the four.

AppGraphNote

Ƭ AppGraphNote: [x: number, y: number, node: number, text: string] One note: [x, y, node, text]. node is the index of the node it is attached to, or -1 for a free note; text is 1 to GRAPH_NOTE_CHARS characters, not blank. Positions are integers within ±100000, like nodes’.

AppGraphGroup

Ƭ AppGraphGroup: [name: string, collapsed: 0 | 1, members: number[]] One named group: [name, collapsed, members]. The name is 1 to GRAPH_GROUP_NAME characters, not blank; collapsed is 0 or 1; members are at least two node indexes, strictly increasing, and no node belongs to two groups.

AppSavedGraphTypeStyle

Ƭ AppSavedGraphTypeStyle: Object One node type’s part of a saved style, by property name.

Type declaration

Name	Type	Description
`collection`	`string`	-
`color?`	`string`	-
`label?`	`string`	-
`badges?`	`string`[]	One or two property names.
`time?`	`string`	-

AppSavedGraphStyle

Ƭ AppSavedGraphStyle: Object One of a member’s named graph styles: a style for each of 1 to 16 object types, by name. Saved in their preferences, so it follows them to any graph and device. It is checked for shape and size only, never against the catalog: a type or property that is no longer available is dropped, and named, when the style is applied.

Type declaration

Name	Type	Description
`name`	`string`	1 to 40 characters, distinct among the member’s styles.
`types`	`AppSavedGraphTypeStyle`[]	-

AppIntent

Ƭ AppIntent: "neutral" | "info" | "success" | "warning" | "danger" Colour meaning for a displayed value. It is presentation, not authority.

AppInlineEdit

Ƭ AppInlineEdit: Object An in-place edit of one property, made by invoking a declared operation. It is presentation: it says which exposed operation changes this property and which of its arguments receives the new value, so a table cell or a property row can offer the edit. It grants nothing. An edit is never a direct property write: the cell previews and invokes operation through the ordinary operation path, with the same authorization, custody and recovery as the operation dialog, and a caller who may not invoke it sees a refused control. The operation is a root operation this application exposes, associated with this collection and declaring a target argument, which receives the edited object’s id. argument accepts every value the property can hold. The frontend fills other arguments from its current read, using its own form configuration (for example a revision guard). The operation checks concurrency and every supplied value. A withheld operation has no control. batch names an exposed operation that applies the same change to a selection: it declares selectionArgument and takes exactly that argument and argument, under the same name.

Type declaration

Name	Type
`operation`	`string`
`argument`	`string`
`batch?`	`string`

AppManifest

Ƭ AppManifest: Object A frontend entry, independent of backend definitions and credentials.

Type declaration

Name	Type	Description
`id`	`string`	-
`name`	`string`	-
`entry`	`string`	-
`api`	`string`	Module exporting the application’s ordinary public queries.
`authentication?`	`"required"` \| `"optional"`	Login behavior only; backend resource policies remain authoritative. Defaults to required.
`objectRoutes?`	`Record`<`string`, `string`>	Hash routes keyed by collection (or *), with {collection} and {id} placeholders.

AppPropertyStatus

Ƭ AppPropertyStatus: "experimental" | "deprecated" An optional advisory label on a collection property.

AppPresentation

Ƭ AppPresentation: Object Presentation metadata grants no data or operation authority.

Type declaration

Name	Type	Description
`inspection?`	`AppInspectionMetadata`	-
`label?`	`string`	-
`description?`	`string`	-
`icon?`	`string`	A lucide icon name in kebab-case; unknown names fall back in the app.
`titleProperty?`	`string`	-
`selectionArgument?`	{ `argument`: `string` ; `fields`: `Record`<`string`, `string`> ; `maxItems`: `number` }	Prefill a native batch operation from the current authorized selection.
`selectionArgument.argument`	`string`	-
`selectionArgument.fields`	`Record`<`string`, `string`>	-
`selectionArgument.maxItems`	`number`	-
`worklist?`	{ `status`: `string` ; `active`: `string`[] ; `assignee?`: `string` ; `due?`: `string` ; `priority?`: `string` }	A customer-owned work queue, displayed on the workspace home.
`worklist.status`	`string`	-
`worklist.active`	`string`[]	-
`worklist.assignee?`	`string`	-
`worklist.due?`	`string`	-
`worklist.priority?`	`string`	-
`defaultColumns?`	`string`[]	-
`defaultMapField?`	`string`	The declared geometry or series property a map of this collection draws unless a view chooses another; absent, the first geometry property in name order, else the first series property (see `appMapFields`). The catalog refuses any other name. A view that draws only geometry (the explorer’s map) draws the first geometry property when this names a series.
`event?`	{ `start`: `string` ; `end?`: `string` ; `severity?`: `string` }	This collection’s objects are events: `start` and `end` name declared date dimensions (dateDimensions) holding when each began and, when known, ended; `severity` a declared dimension. A map lists the events linked to a selected object (through the object’s declared relations to this collection) and draws them on its timeline. Presentation only; the catalog refuses names that are not declared.
`event.start`	`string`	-
`event.end?`	`string`	-
`event.severity?`	`string`	-
`properties?`	`Record`<`string`, { `label?`: `string` ; `description?`: `string` ; `status?`: `AppPropertyStatus` ; `group?`: `string` ; `unit?`: `string` ; `prominent?`: `boolean` ; `format?`: `"text"` \| `"integer"` \| `"decimal"` \| `"currency"` \| `"percent"` \| `"date"` \| `"datetime"` \| `"status"` \| `"json"` \| `"geometry"` \| `"h3"` \| `"geohash"` ; `hidden?`: `boolean` ; `intents?`: `Record`<`string`, `AppIntent`> ; `scale?`: `number` ; `decimals?`: `number` ; `currency?`: `string` ; `ranges?`: { `from?`: `string` ; `to?`: `string` ; `intent`: `AppIntent` }[] ; `edit?`: `AppInlineEdit` ; `point?`: { `longitude`: `string` ; `latitude`: `string` } ; `line?`: { `from`: `string` ; `to`: `string` } ; `cell?`: { `of`: `string` ; `parent?`: `string` } ; `series?`: { `id`: `string` ; `interpolation?`: `"linear"` \| `"nearest"` \| `"previous"` \| `"next"` \| `"none"` ; `measures?`: `Record`<`string`, { `label`: `string` ; `unit?`: `string` }> ; `style?`: `AppLayerStyle` } ; `boundary?`: { `collection`: `string` ; `key`: `string` } ; `expression?`: { `of`: `string` ; `value`: `SeriesExpressionNode` ; `unit?`: `string` ; `max_gap_ms?`: `number` } ; `media?`: { `kind`: `"image"` } \| { `kind`: `"imagery"` ; `footprint`: `string` } \| { `kind`: `"file"` ; `name?`: `string` } \| { `kind`: `"vector"` } & { `attachment?`: `string` } ; `lookup?`: `string` }>	-
`feature?`	`string`	The exposed id this operation belongs to. It is presentation, like every other field here: it says WHERE a control for this operation belongs, so a capability’s own panel can offer the product’s declared operation instead of growing a second control of its own. It grants nothing, it does not narrow who may invoke the operation, and the operation stays in the workspace’s ordinary action surfaces. A value that does not name a feature this application exposes is refused when the application definition is built. Only an operation may declare one; a collection may not.
`intent?`	`AppIntent`	What this operation MEANS, declared rather than guessed. `danger` marks a withdrawal, a rejection or a cancellation, so a surface can give its control the destructive treatment without reading the label. The shared UI never infers meaning from a name or a business word, so an operation that declares nothing is neutral. Only an operation may declare one; a collection may not.
`sortIndexes?`	`Record`<`string`, `string`>	Only explicitly declared indexed orderings are offered to applications.
`search?`	{ `field`: `string` ; `index`: `string` }	How the workspace finds objects of this collection by text: `field` is searched through `index`. When `index` names one of the collection’s search_indexes whose `searchField` is `field`, search matches words: the engine’s full-text index tokenizes the text and folds case, the last word may be a prefix, and results come in relevance order, one bounded page. A view searches the text index of its source that it carries (see AppSearchIndex). Otherwise `index` is an ordinary index whose first field is `field`, and search is an exact, case-sensitive prefix of the stored text read in index order: indexes order strings by their UTF-8 bytes with no collation. That form is admitted only while no search index of the collection covers `field`. appSearchMode says which one applies.
`search.field`	`string`	-
`search.index`	`string`	-
`relations?`	`Record`<`string`, `AppRelation`>	Named traversals to other collections. The application derives them from the navigation the schema’s `.reference(...)` and `.link(...)` declarations give the collection’s identity table; a program only labels, selects or leaves one out (`expose(...).relations`).
`is_connection?`	`boolean`	A connection type may be discoverable without appearing in the ordinary picker.
`comments?`	`AppComments`	Discussion through an existing relation and declared operations, checked when the catalog is built; see AppComments.
`dimensions?`	`string`[]	-
`measures?`	`string`[]	-
`dateDimensions?`	`string`[]	Date properties the workspace may range over and bucket. Each entry names an admitted property whose properties `format` is `date` or `datetime` and which declares a sortIndexes entry, the same indexed-ordering gate sorting uses. The `between` predicate and the facet histogram are admitted only on a declared date dimension.
`numericDimensions?`	`string`[]	Numeric properties the workspace may range over and bucket: at most four, each an admitted property declared `v.int64()` or `v.float64()` (optional allowed, never a union), and none also a date dimension. The facet rail returns a bounded histogram of each (AppFacetNumericHistogram), and a `between` range, with an open side allowed, is admitted on each.

AppOperationLayout

Ƭ AppOperationLayout: AppPresentation Operation presentation without form initialization or dependent-field behavior.

AppViewDependency

Ƭ AppViewDependency: Object Declared dependencies of a view, restricted to collections this app exposes. A view may also read tables the app does not expose; that is never disclosed, not even as a count.

Type declaration

Name	Type	Description
`plan?`	`ViewPlanExplanation`	Native plan metadata, available when all input schemas are visible.
`mode`	`ViewMode`	`computed` is evaluated when read; `stored` is maintained with its inputs.
`inputs`	`string`[]	Exposed collection names among the view’s referenced tables, sorted.
`columns`	`AppViewColumns`	Declared column lineage among exposed inputs; see AppViewColumns.

AppSourceDependency

Ƭ AppSourceDependency: Object Declared binding of a source-owned table: program-authored names only.

Type declaration

Name	Type	Description
`integration`	`string`	The program’s own integration export name, such as `erp` or `postgres`. It may name a technology when the author chose such a name. Never the module path.
`collection`	`string`	The program’s collection name within that integration, never a physical relation.

AppPublishedDependency

Ƭ AppPublishedDependency: Object Declared producer and member of a published relation.

Type declaration

Name	Type
`producer`	`string`
`member`	`string`

AppReadCost

Ƭ AppReadCost: { kind: "free" } | { kind: "per_row" ; subjects: number ; indexes: string[] } | { kind: "per_object" ; subjects: number } | { kind: "unbounded" } How reading a collection is charged against READ_SUBJECT_LIMIT, reported by the engine.

free: no per-row charge; the ordinary row bounds apply.
per_row: subjects per row a read’s range VISITS, matching or not, through the default ordering and through each index named in indexes. A read through an index not listed is unbounded: a view index that cannot reuse a source index with the same fields scans its whole source.
per_object: a read’s range costs the decisions its rule makes of the range, not its rows, so ordinary row bounds apply; subjects per object read by identity (objects, labels, a link’s target). The table’s rule is a closed access program.
unbounded: no bound in visited rows exists (a view that reads protected rows it does not return, a materialized view over protected inputs, a relation whose rows restore retained obligations, a published relation). Bounded reads of it are reported incomplete, and paged reads refused, rather than failing the engine’s bound part way.

AppAggregate

Ƭ AppAggregate: Object One aggregate the collection’s table declares, which the engine keeps exact in the same commit as every write: counts per value of by, and an exact int64 sum of each sum field. visibility says whether it is served under a read rule (see TableDefinition.aggregate). Reported by the engine; a presentation cannot declare it.

Type declaration

Name	Type	Description
`name`	`string`	-
`by`	`string`[]	-
`sum`	`string`[]	-
`decimal?`	`Record`<`string`, `number`>	Exact string measures keyed by their fixed scale.
`visibility`	`"unprotected"` \| `"collectionReaders"`	-
`time?`	{ `field`: `string` ; `unit`: `AppTimeUnit` }	A declared UTC calendar dimension; raw grouping cannot read these keys.
`time.field`	`string`	-
`time.unit`	`AppTimeUnit`	-

AppSearchIndex

Ƭ AppSearchIndex: Object One full-text index a search of a collection reads, reported by the engine: a table’s own searchIndex, or one its source declares that a view carries. A view cannot declare a search index. A computed view carries its source’s when its rows are the source’s rows one for one (a scan, renamed or re-projected, never filtered, joined or grouped) and it shows the search field and every filter field unchanged under the same name. The engine then runs the source’s search under the caller’s authority, passes each hit through the view’s plan and read rule, and keeps the relevance order.

Type declaration

Name	Type
`indexDescriptor`	`string`
`searchField`	`string`
`filterFields`	`string`[]

AppSearchMode

Ƭ AppSearchMode: "words" | "prefix" How a collection’s declared search matches: words through a full-text index (any case, relevance order), prefix through an ordinary index (exact, case-sensitive, index order).

AppRelation

Ƭ AppRelation: Object A presented named navigation. Physical joins remain owned by the engine.

Type declaration

Name	Type	Description
`label`	`string`	-
`collection`	`string`	-
`navigation`	`string`	-
`inverse?`	`string` \| `null`	The inverse native navigation, when declared.
`cardinality`	{ `min`: `number` ; `max`: `number` \| `null` }	-
`cardinality.min`	`number`	-
`cardinality.max`	`number` \| `null`	-
`orderBy`	`string`[]	-

AppRelatedEntry

Ƭ AppRelatedEntry: Object An identity reached by a relation; an unavailable source retains its ID.

Type declaration

Name	Type
`id`	`string`
`document`	`AppObject` \| `null`

AppRelatedWindowPage

Ƭ AppRelatedWindowPage: RelatedWindowPage A relationship page at one exact, expiring basis.

AppRelatedPage

Ƭ AppRelatedPage: RelatedPage

AppCollection

Ƭ AppCollection: AppPresentation & { resource_id: string ; relationContract?: RelationDescriptor ; name: string ; component?: string ; kind: "table" | "view" | "source" | "published" | "virtual_table" ; snapshot_browse?: boolean ; identity_table: string ; references?: Record<string, { relation: string | null ; inverse: string | null }> ; view: AppViewDependency | null ; source: AppSourceDependency | null ; published: AppPublishedDependency | null ; validator_json: string ; series_properties?: Record<string, AppSeriesProperty> ; file_fields?: FileFieldProjection[] ; spatial_fields?: Record<string, AppSpatialField> ; indexes: { indexDescriptor: string ; fields: string[] ; spatial?: { field: string ; encoding: "wgs84-zorder29-cover-v2" } }[] ; search_indexes: AppSearchIndex[] ; relationships: null | { field: string ; table: string ; min: number ; max: number | null ; navigation?: string | null }[] ; read_cost: AppReadCost ; aggregates: AppAggregate[] ; spatial_indexes: AppSpatialIndexInfo[] ; property_order: string[] ; series_gaps?: Record<string, number | null> } An active collection explicitly exposed by the product query.

OperationAuthorization

Ƭ OperationAuthorization: { kind: "model" ; bindingDigest: string ; resource: { type: "operation" ; key: string } } | { kind: "custom" } Exact native operation contract, with current discovery-time permissions.

AppOperation

Ƭ AppOperation: AppPresentation & { name: string ; pipeline_operation?: string ; pipeline_keys?: string[] ; pipeline_selector?: string ; access: OperationAuthorization ; datasetSave?: Extract<DiscoveryDescription, { kind: "operation" }>["datasetSave"] ; contract_json: string ; contract_digest: string ; is_invokable: boolean ; is_previewable: boolean ; component?: string ; forwarder?: string }

AppOperationAdapters

Ƭ AppOperationAdapters: { reference: OperationReference ; contract: OperationContract } & OperationFunctionReferences<"public", any, any> The five companion references one catalog entry resolves to, whoever declared the operation.

AppFeature

Ƭ AppFeature: Object A capability the application exposes beside its collections and operations. The entry is disclosure metadata: it names a public module and grants nothing. The feature’s own module enforces authentication and access for every call.

Type declaration

Name	Type	Description
`inspection?`	`AppInspectionMetadata`	-
`pipelines?`	`PipelineCatalogEntry`[]	Resolved by the authorized catalog; never authored feature configuration.
`id`	`string`	Stable kebab-case identity of this installation in the application.
`kind`	`string`	Capability category, such as `datasets`; several installations may share it.
`module`	`string`	The customer’s public Bijection module exporting this feature’s functions.
`presentation?`	`Record`<`string`, `AppCallablePresentation`>	Optional descriptions keyed by exact exported callable names.
`label?`	`string`	-
`description?`	`string`	-
`icon?`	`string`	A lucide icon name in kebab-case.

PipelineCatalogEntry

Ƭ PipelineCatalogEntry: Object

Type declaration

Name	Type	Description
`program_kind?`	`string`	The program’s kind, such as `typescript` or `sqlmesh`.
`key`	`string`	-
`label`	`string`	-
`capabilities`	`string`[]	-

AppCallablePresentation

Ƭ AppCallablePresentation: Object Shared descriptions for generated clients; never execution or authorization.

Type declaration

Name	Type	Description
`inspection?`	`AppInspectionMetadata`	-
`description?`	`string`	-
`examples?`	{ `args_json`: `string` }[]	Complete arguments in lossless JSON, preserving tagged exact values.
`columns?`	`string`[]	-

AppCallable

Ƭ AppCallable: { pipeline_reader?: string ; pipeline_keys?: string[] ; pipeline_control?: string ; feature: string ; name: string ; address: string ; args_json: string ; returns_json: string ; presentation?: AppCallablePresentation } & { kind: "query" | "mutation" | "action" } | { kind: "operation" ; operation: AppOperation } A deployed callable, resolved from the exposed module’s native analysis.

AppCatalog

Ƭ AppCatalog: Object The authorized catalog; it contains no policy code or connector configuration.

Type declaration

Name	Type	Description
`api_version`	typeof `WORKSPACE_API_VERSION`	-
`notificationKinds`	`Record`<`string`, `string`>	-
`integrations?`	`Record`<`string`, { `label`: `string` ; `icon?`: `string` ; `description?`: `string` }>	Presentation of integrations feeding the caller’s exposed source types. Absent when the program supplies no integration presentation.
`people?`	`string`	The exposed collection whose objects are the application’s people (`defineApplication({ people })`): a person id is an id of this collection, and a person’s name is its title. Absent when the application declares no people.
`sharesWithPeople?`	`true`	Present when the application declares a share table and its people are served to the caller: saved views and graphs are then shared with named people (`share`); otherwise only with every member.
`collections`	`AppCollection`[]	-
`restricted_collections?`	`number`	Exposed collections withheld whole from this caller, because every row derives from data they are not cleared for (`defineApplication({ readable })`): left out of `collections` and counted here, never named. Absent when none is withheld.
`operations`	`AppOperation`[]	-
`features`	`AppFeature`[]	-
`callables`	`AppCallable`[]	-
`maps`	{ `settings`: `boolean` ; `places`: `boolean` ; `values`: { `name`: `string` ; `label`: `string` ; `collection`: `string` }[] ; `searchArounds`: { `name`: `string` ; `label`: `string` ; `from`: `string` ; `collection`: `string` }[] ; `archives`: { `key`: `string` ; `label`: `string` ; `dataset`: `string` ; `column`: `string` ; `collection`: `string` ; `property`: `string` }[] }	What the program registers for maps: deployment map settings and basemaps (`defineApplication({ maps })`), location search (`places`) and function-driven style values (`mapValues`, by name, each for one collection).
`maps.settings`	`boolean`	-
`maps.places`	`boolean`	-
`maps.values`	{ `name`: `string` ; `label`: `string` ; `collection`: `string` }[]	-
`maps.searchArounds`	{ `name`: `string` ; `label`: `string` ; `from`: `string` ; `collection`: `string` }[]	Registered Search Around functions (`searchArounds`): each reads from one collection and returns objects of another.
`maps.archives`	{ `key`: `string` ; `label`: `string` ; `dataset`: `string` ; `column`: `string` ; `collection`: `string` ; `property`: `string` }[]	Declared map archives (`maps.archives`; an external producer records their versions through `@bijectionhq/datasets/map-archive`): the PMTiles tile archive of a dataset’s geometry column, drawn by an overlay naming `key`; its current object is `collection`’s, holding the archive in `property`. Listed only while `collection` is served to the caller and the dataset’s read rule admits them.

AppObject

Ƭ AppObject: Record<string, Value> & { _id: string ; _creationTime: number } One ordinary object returned under the caller’s current read rules.

AppPageEnd

Ƭ AppPageEnd: "complete" | "page" | "budget" | "window" Why a page ended, and whether continueCursor continues it.

complete: the whole range, or the whole ranking, was read (isDone).
page: the page holds the objects requested; the cursor continues.
budget: fewer objects than requested and more to read. The query’s own read bound (rows visited, bytes, or the engine’s read-access subjects, see APP_READ_SUBJECT_BUDGET) ended the page first, or a re-run of a pinned page found rows gone from its range. The cursor continues exactly after the last row read, so continuing fills the page; it is never an error and never a count.
window: a word search reached the end of the engine’s ranking, its first APP_SEARCH_WINDOW matches by relevance. More may match; no cursor reaches them. Add words to narrow the search.

AppPage

Ƭ AppPage: Object One page of objects. end says machine-readably why it ended (AppPageEnd); a page may be short or empty and still continue. A cursor is a position in the page’s index or ranking, not a snapshot. A reactive client re-runs every page it holds at the one snapshot its subscriptions share, and a page keeps its end position after its first answer (the inherited query journal), so the pages loaded from one start partition the range: none repeats or skips an object. A one-shot continuation re-bases on the latest state instead, so an object that moved between two reads may be seen twice or not at all.

Type declaration

Name	Type	Description
`page`	`AppObject`[]	-
`isDone`	`boolean`	-
`continueCursor`	`string`	-
`end`	`AppPageEnd`	-
`distances?`	`Record`<`string`, `number`>	With nearest: each listed object’s great-circle distance in metres from the center, by id.
`order?`	`"index"`	`index` when the page lists its objects in the spatial index’s order, not the view’s (`orderBy`, `order`): readers such as object tiles that explicitly request the spatial index’s order. Browse walks the requested order, merging admitted partition ranges when needed. Absent when the view’s order holds.

AppDecimalTotal

Ƭ AppDecimalTotal: Object An exact fixed-scale decimal total. Numeric extrema are unavailable on the maintained path; string indexes do not order decimals numerically.

Type declaration

Name	Type
`scale`	`number`
`sum`	`string`
`min`	`string` \| `null`
`max`	`string` \| `null`

AppSummary

Ƭ AppSummary: Object

Type declaration

Name	Type	Description
`path`	`"maintained"` \| `"bounded"` \| `"source"`	`maintained` and `bounded` are native reads; `source` is one statement a virtual table’s source executed (AppVirtualSummary).
`is_complete`	`boolean`	-
`count`	`bigint` \| `null`	-
`groups`	{ `value`: `Value` \| `null` ; `is_missing`: `boolean` ; `value2?`: `Value` \| `null` ; `is_missing2?`: `boolean` ; `count`: `bigint` ; `sum`: `bigint` \| `null` ; `decimal?`: `AppDecimalTotal` ; `sums?`: (`bigint` \| `string`)[] ; `percentiles?`: (`bigint` \| `string`)[] ; `min?`: `bigint` \| `null` ; `max?`: `bigint` \| `null` }[]	-
`limit`	`number`	-
`incomplete`	`AppSummaryIncomplete` \| `null`	Null exactly when `is_complete`.
`extremes?`	`AppSummaryExtremes`	Present exactly when `measure` is requested and the summary is complete: whether the groups’ `min`/`max` are exact.
`time?`	`AppTimeAxis`	Present exactly when `bucket` was requested and the summary is complete.
`other?`	{ `values`: `number` ; `count`: `bigint` ; `sum`: `bigint` \| `null` ; `decimal?`: `AppDecimalTotal` ; `sums?`: (`bigint` \| `string`)[] ; `percentiles?`: (`bigint` \| `string`)[] ; `min?`: `bigint` \| `null` ; `max?`: `bigint` \| `null` } \| `null`	Present exactly when `top` was requested and the summary is complete: the groups past the `top` largest, as one exact remainder — `values` first-grouping values folded, the objects they `count` and the exact `sum` of the measure (null without one) — or null when nothing was folded. `count` of the summary includes them. With a `measure`, `min` and `max` are the exact extremes over the folded groups, null unless every folded group has its own.

AppSummaryExtremes

Ƭ AppSummaryExtremes: { kind: "exact" } | { kind: "not_indexed" ; index: string[] } | { kind: "scope" } | { kind: "decimal" } | { kind: "bound" } Whether a summary’s min/max are exact.

exact: every group’s are. Always so on the bounded path; on the maintained path each group’s extremes are the first and last entry of an index whose fields are the grouped and filtered properties (in any order) followed by the measure: two single-row reads per group, tracked like any read, so they stay exact under inserts, updates and deletes.
not_indexed: no enabled index orders the measure under exactly those properties, so min/max are null; index lists the fields of one that would (the properties, then the measure). Counts and sums are unaffected.
scope: calendar or range totals cannot use two point probes for exact extremes; no index declaration is suggested.
bound: the rows those reads fetch would pass the engine’s 4 MiB bound; min/max are null.

AppTimeAxis

Ƭ AppTimeAxis: Object Calendar buckets of one date dimension: UTC-aligned (weeks start on Monday), closed-open, in the property’s own representation, so a bucket selects exactly as a between [from, to) predicate. The unit is the requested one or the first wider one whose span fits 60 buckets.

Type declaration

Name	Type
`field`	`string`
`unit`	`AppTimeUnit`
`buckets`	{ `from`: `Value` ; `to`: `Value` }[]

AppTimeTransform

Ƭ AppTimeTransform: { kind: "cumulative" } | { kind: "rolling" ; buckets: number } | { kind: "change" ; against: "previous" | "year" } Presentation over a complete time axis; no additional read.

AppAggregateRefusal

Ƭ AppAggregateRefusal: "not_declared" | "visibility" | "building" | "groups" | "compacting" | "overflow" | "inexact_measure" | "inexact_dimension" | "pending_value" | "inconsistent" The closed reasons the engine gives for not serving a maintained total (1.0/apps/aggregate). not_declared: no declared aggregate covers the request; visibility: the collection has a read rule and the covering aggregate is not declared collectionReaders; building: its records are still being counted; groups: more groups than the answer reads — a grouping whose groups each occupy one run of the aggregate’s key order (every property declared before the last grouped one is grouped or filtered by equality, and no filtered property follows an unfiltered one) is read in up to 16 pages of at most 256 keys each (a group holds one key per value of the aggregate’s later properties) and is groups at a group of more than 256 keys, and any other grouping past 256 non-empty keys; compacting: one page’s keys hold more than 4,096 terms the engine has not folded yet, so this answer is read from rows until it catches up; overflow: an int64 sum does not fit int64, or a decimal sum exceeds 38 digits, for this answer only — the aggregate stays maintained and serves again once the rows’ total fits; inexact_measure, inexact_dimension, pending_value, inconsistent: the aggregate is unavailable until its next rebuild.

AppSummaryIncomplete

Ƭ AppSummaryIncomplete: { kind: "bound" ; aggregate: { by: string[] ; sum: string[] ; decimal?: Record<string, number> ; time?: { field: string ; unit: AppTimeUnit } } | null ; refused: AppAggregateRefusal | null } | { kind: "related" } | { kind: "region" } | { kind: "nearest" } | { kind: "time_span" } | { kind: "time_value" } | { kind: "source_result" } Why a summary returned no count, for a surface to show what would make it exact.

bound: the read could not finish within its matching-object or visited-row budget (limit; 0 when the collection’s AppReadCost gives this ordering no bound). The limit is not a lower bound on matching objects. aggregate is the declaration, defineTable(...).aggregate(name, { by, sum }), that would answer this scope exactly at any size, or null when no aggregate can cover it (a search, selection, condition group, related clause, predicate other than equality, or more than four grouped and filtered properties). refused is why a declared covering aggregate did not answer, or null when none was asked.
related: a relationship clause admits more candidates than its bound, or a clause tested object by object (AppRelationFilter) met more than 100 objects, an object it could not decide within APP_LINK_PROBE_LINKS links, or the end of the read budget; narrow the filters.
region: the region (within) admits more objects than one read may resolve and no maintained total answers it (see AppSummary maintained), or its spatial index could not read its whole cover within the query’s read budget; draw a smaller one or add filters. A browse pages any region to its end instead.
nearest: the nearest objects the view’s filters admit lie beyond the objects one read may rank (nearest); narrow the filters or the distance.
time_span: the dates need more than 60 calendar years, or widening would split a stored bucket across requested buckets.
time_value: a date value cannot be placed in a bucket exactly (outside the exact millisecond range, or text that is not a normalized UTC instant).
source_result: a virtual table’s answer has more groups, or more bytes, than one source answer carries (limit rows); add filters or group by a property with fewer values.

AppVirtualSummary

Ƭ AppVirtualSummary: Object A summary of a virtual table: one statement its source executed, at the moment received_at this deployment received the complete answer. It is an observation, not a subscription: the source does not notify changes, so a reader asks again to refresh. basis names where the statement ran and plan how; both are null exactly when no complete answer was received (an incomplete source_result summary). summary.path is source.

Type declaration

Name	Type	Description
`summary`	`AppSummary`	-
`basis`	`AnswerCollection`[`"basis"`] \| `null`	-
`plan`	`AnswerPlan` \| `null`	-
`received_at`	`string`	When the complete answer was received, as an ISO 8601 UTC instant: a recording time, not the source’s own freshness.

FacetUnavailableReason

Ƭ FacetUnavailableReason: { kind: "unsupported_type" } | { kind: "too_many_values" ; limit: number } | { kind: "unrepresentable_range" } | { kind: "capacity" } | { kind: "source_failure" ; error: AnswerErrorData } Value counts of a virtual table’s first eight declared dimensions, and its date and int64 numeric histograms, as a native facet read counts them: each over the scope less that dimension’s own eq, in and between conditions. Each dimension has its own population; one with more than 32 values is omitted, not truncated, as natively. The date histogram counts days (months past one answer’s days) at the source and lies on the native axis; a numeric histogram reads its exact extremes, then counts by the native step. A float64 dimension’s histogram is withheld: the source has no exact float comparison. Like a summary it is an observation received at received_at, not a subscription.

FacetResult

Ƭ FacetResult<T>: { kind: "ready" ; value: T } | { kind: "not_requested" } | { kind: "unavailable" ; reason: FacetUnavailableReason } Ready includes exact empty data. Refusal is never represented as zero.

Type parameters

Name
`T`

VirtualHistogram

Ƭ VirtualHistogram: { kind: "date" ; histogram: AppFacetHistogram | null } | { kind: "integer" ; histogram: AppFacetNumericHistogram | null }

AppVirtualFacets

Ƭ AppVirtualFacets: Object

Type declaration

Name	Type	Description
`consistency`	`AnalysisConsistency`	-
`scope`	`AppSummaryArgs`	-
`values`	`Record`<`string`, `FacetResult`<`AppFacets`[`"fields"`][`string`]>>	-
`histograms`	`Record`<`string`, `FacetResult`<`VirtualHistogram`>>	-
`started_at`	`string`	One sealed program supplies every field and histogram.
`answer`	`AnswerDescriptor` \| `null`	-
`plan`	`AnswerPlan` \| `null`	-
`received_at`	`string`	-

AppVirtualRowsView

Ƭ AppVirtualRowsView: Pick<AppView, "collection" | "filters" | "analysisFilters" | "filterMode" | "groups" | "orderBy" | "order" | "columns"> & { asOf?: string } The rows of a virtual table a workspace table shows: the view’s scope, its columns, and its sort. Sorted, a read keeps the first 65,536 rows of that order; unsorted, the source refuses a scope of more rows. A source field is never missing: is_empty selects its NULLs. A declared date dimension compares its day’s UTC midnight exactly, and a relative range the days it selects on asOf, as for a native read. Search, fixed selections, relationship and spatial filters, text containment and list conditions are refused, never approximated.

AppVirtualPlan

Ƭ AppVirtualPlan: Object The statement a view of a virtual table means, as the relational expression’s JSON. A summary’s layout names which grouped fields and measures its rows hold; a table’s is null.

Type declaration

Name	Type	Description
`requests?`	{ `values`: `Record`<`string`, `FacetResult`<`never`>> ; `histograms`: `Record`<`string`, `FacetResult`<`never`>> }	Present for facets, including declared fields the bounded plan omits.
`requests.values`	`Record`<`string`, `FacetResult`<`never`>>	-
`requests.histograms`	`Record`<`string`, `FacetResult`<`never`>>	-
`facets?`	{ `field`: `string` ; `expression_json`: `string` }[]	Present for `facets`: each declared dimension’s count statement.
`histogram?`	{ `field`: `string` ; `by_day`: { `expression_json`: `string` ; `layout`: `VirtualSummaryLayout` } ; `by_month`: { `expression_json`: `string` ; `layout`: `VirtualSummaryLayout` } }	Present for `facets` with a date dimension: its count by day, and by month for a span whose days exceed one answer.
`histogram.field`	`string`	-
`histogram.by_day`	{ `expression_json`: `string` ; `layout`: `VirtualSummaryLayout` }	-
`histogram.by_day.expression_json`	`string`	-
`histogram.by_day.layout`	`VirtualSummaryLayout`	-
`histogram.by_month`	{ `expression_json`: `string` ; `layout`: `VirtualSummaryLayout` }	-
`histogram.by_month.expression_json`	`string`	-
`histogram.by_month.layout`	`VirtualSummaryLayout`	-
`numeric?`	{ `fields`: `string`[] ; `scope_json`: `string` }[]	Present for `facets` with int64 numeric dimensions: the scope each is counted over, shared by the dimensions whose scopes are equal.
`expression_json`	`string`	-
`layout`	{ `groups`: `string`[] ; `measures`: `string`[] ; `measured`: `boolean` ; `scales?`: (`number` \| `null`)[] ; `bucket?`: { `field`: `string` ; `unit`: `AppTimeUnit` } } \| `null`	-

AppRequester

Ƭ AppRequester: { kind: "service" ; label: string ; service: string ; is_you: boolean } | { kind: "member" ; label: string ; is_you: boolean } | { kind: "delegate" ; label: string ; client_label: string ; is_you: boolean } | { kind: "system" ; is_you: boolean } Who made an accepted request, recorded by the engine when it accepted it. label is a display snapshot of the requester’s sign-in claims (name, else email, else preferred username, else subject), the same derivation AppAccessRequestPerson uses. It is never identity and never a workspace person’s name. A delegate is a person’s delegation to agent, labelled with that person. is_you compares the reader with the recorded caller now, not the label.

AppSharedReviewState

Ƭ AppSharedReviewState: Object What another requester’s row discloses of its review: the kind only, never an approval, approver, beneficiary or refused external call.

Type declaration

Name	Type
`kind`	`OperationReviewState`[`"kind"`]

AppActivity

Ƭ AppActivity: Object One accepted request. Without a target, activity lists the reader’s own requests. With one, it lists the object’s requests the reader may see: their own, and other people’s through an operation that declares activity: "shared" both now and when the request was accepted, to a reader who may read the object and holds read on the operation.

Type declaration

Name	Type	Description
`request_id`	`string`	-
`request_owner_id`	`string`	-
`operation`	`string`	The operation’s path inside the component that declares it: the same `module:export` its contract names.
`component?`	`string`	The installed component that declares the operation, absent for one the root program declares, exactly as on its AppOperation catalog entry. Together with `operation` it identifies that entry: two components may export the same `module:export`. A component operation’s `target` names an object in that component’s namespace, not an exposed collection.
`contract_digest`	`string`	-
`state`	`string`	-
`accepted_at`	`bigint`	When this deployment recorded the request, in exact epoch milliseconds like every other instant on this page: the commit timestamp of the transaction that accepted it, truncated to the millisecond. The retained row is written by that same transaction, so this is the instant of acceptance as the engine recorded it, and the later expiry of the retained result does not move it. It is not a business valid time, not the instant any external call was delivered, and not an observation of any source. The request’s own receipt and `__status` companion report the same commit timestamp at full nanosecond resolution as `accepted_revision`.
`target`	{ `view`: `string` ; `id`: `string` } \| `null`	-
`requester`	`AppRequester`	-
`phase`	`OperationPhase`	The engine’s phase and attention for the request, as its `__status` companion reports them. Content-free kinds, so present on every row.
`attention`	`OperationAttention` \| `null`	-
`review`	`OperationReviewState` \| `AppSharedReviewState`	The full review state exactly when `requester.is_you`; the kind only on another requester’s row.

AppActivityPage

Ƭ AppActivityPage: Object

Type declaration

Name	Type
`data`	`AppActivity`[]
`next_cursor`	`string` \| `null`

AppFilter

Ƭ AppFilter: Object A typed predicate. in/not_in carry an array of 1–32 values; is_empty/is_not_empty carry null; between carries exactly two bounds [from, to] of the property’s own type and means the closed-open range from <= value < to. between is admitted only on a declared dateDimensions or numericDimensions property. On a numeric dimension one bound may be null for an open side ([from, null] is from <= value, [null, to] is value < to); an object without the property never matches a range. An inclusive maximum is written as the exclusive bound appInclusiveUpperBound returns.

contains: a text property (a string, or a union with a string member) holds the value, 1–128 characters, ignoring case; a missing, null or non-text value never contains.
has_any / has_none: a list property holds at least one / none of 1–32 exact element values (an int64 1n is never the float64 1). A missing list holds none.
relative: an AppRelativeRange on a declared date dimension, saved as written and resolved to the between it means on the UTC day a read names (asOf, see appRelativeBounds).

contains, has_any and has_none are evaluated over the rows the native read returned (the same rows, so the same dependencies), so a page holding them may end short with budget (AppPageEnd). Search Around hops and an object’s related records (where) refuse these four operators.

Type declaration

Name	Type
`field`	`string`
`operator?`	`"eq"` \| `"neq"` \| `"gt"` \| `"gte"` \| `"lt"` \| `"lte"` \| `"in"` \| `"not_in"` \| `"between"` \| `"is_empty"` \| `"is_not_empty"` \| `"contains"` \| `"has_any"` \| `"has_none"` \| `"relative"`
`value`	`Value`

AppRelativeUnit

Ƭ AppRelativeUnit: "day" | "week" | "month"

AppRelativeRange

Ƭ AppRelativeRange: Object A date range relative to the day it is read on, in whole UTC calendar units: 0 is the unit holding that day (the day itself, its Monday-to-Sunday week, its month), -1 the one before. from is the first unit in the range and to the last, inclusive; null leaves that side open, never both. Each offset is an integer within ±3660, and from <= to. “Last 7 days” is { unit: "day", from: -6, to: 0 }, “Last month” { unit: "month", from: -1, to: -1 }, “Before today” { unit: "day", from: null, to: -1 }.

Type declaration

Name	Type
`unit`	`AppRelativeUnit`
`from`	`number` \| `null`
`to`	`number` \| `null`

AppFilterGroup

Ƭ AppFilterGroup: Object Conditions combined by match: its filters and its spatial clauses (within, each a region over one of spatial_indexes related by one of its modes, disjoint as the negation of intersects). A view holds at most APP_SPATIAL_CLAUSES spatial clauses in all, its own within included. A group’s spatial clause is tested on each object the view reads with its index’s own predicate; when the view has no within of its own and no nearest or relationship clause, an all group’s clause (or the only member of an any group) also reads the view’s candidates through its index.

Type declaration

Name	Type
`match`	`"all"` \| `"any"`
`filters`	`AppFilter`[]
`within?`	`AppWithin`[]

AppRelationFilter

Ƭ AppRelationFilter: Object A relationship clause: keep the objects with at least one (has: "some", the default) or with no (has: "none") linked object of relation that matches all of filters (0 to 8 conditions; with none, any linked object counts) and, with within, relates to a region by a geometry property of the linked collection with a spatial index (decided by that index). A view holds at most APP_RELATION_CLAUSES. A clause whose conditions include an eq on an indexed property of the linked collection reads its matching linked objects once (at most 128) and keeps the objects they link to, or all others; so does a clause with within, reading the linked objects its region holds through the linked collection’s spatial index (at most APP_LINK_JOIN_CANDIDATES, further bounded by bytes, linking reads and read-access subjects). Any other clause tests each object’s own links as the object is read: at most APP_LINK_PROBE_LINKS links of one object per clause, so an object with more links none of which match refuses the read by name, and a summary or facet read tests at most 100 objects (beyond that it is incomplete, related). A clause without such an equality or region cannot be combined with a region or nearest objects.

Type declaration

Name	Type
`relation`	`string`
`filters`	`AppFilter`[]
`match?`	`"all"` \| `"any"`
`has?`	`"some"` \| `"none"`
`within?`	`AppWithin`

AppSearchHop

Ƭ AppSearchHop: Object One hop of a Search Around: a declared relation of the previous hop’s collection (a reference, incident record or opposite endpoint), the filters its targets must all match and, with within, the region a geometry property of the targets relates to, decided by the target collection’s spatial index (an object region is read with the caller’s point read).

Type declaration

Name	Type
`relation`	`string`
`where?`	`AppFilter`[]
`within?`	`AppWithin`

AppSearchAround

Ƭ AppSearchAround: Object One starting object’s Search Around, read at one basis under the caller’s authority. A denied dependent read refuses the whole answer, including a relation range; unavailable retained identities remain explicit entries. Each hop lists the distinct objects of collection that matched its where, each with the ids of the previous hop’s objects (or the starting object) that reached it. is_complete is true only when the previous hop was complete and every range and reference this hop needed was read and tested within the bounds; otherwise more objects may match. It is never a total across starting objects.

Type declaration

Name	Type
`hops`	{ `collection`: `string` ; `objects`: { `id`: `string` ; `from`: `string`[] ; `available`: `boolean` }[] ; `is_complete`: `boolean` ; `stopped`: `AppSearchAroundStop` \| `null` }[]

AppSearchAroundStop

Ƭ AppSearchAroundStop: "budget" | "bound" | "previous"

AppObjectLabel

Ƭ AppObjectLabel: Object

Type declaration

Name	Type	Description
`collection`	`string`	-
`id`	`string`	-
`title`	`string` \| `null`	-
`restricted?`	`true`	Set by `labels` when the caller may not read this object; `title` is then null. See AppPointRead.

AppSearchGroup

Ƭ AppSearchGroup: Object One searchable type’s answer to the workspace search query. objects are the type’s best matches in its search order, at most the call’s limit. is_complete is false when more objects matched, or when the read budget stopped the read first: objects.length is then a lower bound, and an incomplete group with no objects was not counted at all. A count is never extrapolated.

Type declaration

Name	Type	Description
`collection`	`string`	-
`label`	`string`	-
`mode`	`AppSearchMode`	How this type’s objects matched the text.
`objects`	`AppObjectLabel`[]	-
`is_complete`	`boolean`	-

AppPointRead

Ƭ AppPointRead: { id: string ; kind: "object" ; object: AppObject } | { id: string ; kind: "absent" } | { id: string ; kind: "restricted" } One identifier’s answer from a restrictable point read: the workspace’s getMany query, or getMany in a program’s own query.

object: the object, exactly as db.get returns it.
absent: there is no such object. Only a caller whose authority covers the whole relation is told so, because an absent identifier is a demand on the whole relation.
restricted: the engine refused this read for the caller. The object may exist and be unreadable, may never have existed, or may have been erased; nothing says which, and nothing says why.

Each identifier is decided on its own, so one refused object no longer refuses the others. Every other read in the same query is still decided with the whole answer. See the authorization contract’s “Restricted point reads”.

AppView

Ƭ AppView: Object Persistable query definition; object selection and paging are separate.

Type declaration

Name	Type	Description
`collection`	`string`	-
`filters?`	`AppFilter`[]	-
`filterMode?`	`"all"` \| `"any"`	-
`analysisFilters?`	`AppFilter`[]	Chart selections intersect the filter expression, including match-any groups.
`groups?`	`AppFilterGroup`[]	-
`related?`	`AppRelationFilter`[]	-
`ids?`	`string`[]	-
`linked?`	{ `collection`: `string` ; `id`: `string` ; `path`: `string`[] }	Select through one or two named relations from one starting identity.
`linked.collection`	`string`	-
`linked.id`	`string`	-
`linked.path`	`string`[]	-
`columnWidths?`	`Record`<`string`, `number`>	-
`pinnedColumns?`	`string`[]	-
`wrapCells?`	`boolean`	-
`order?`	`"asc"` \| `"desc"`	-
`orderBy?`	`string`	-
`search?`	`string`	Text matched by the collection’s declared search (appSearchMode). A word search orders by relevance, so it takes no `orderBy`, and pages continue through the ranking up to APP_SEARCH_WINDOW matches; a prefix search orders by its property.
`columns?`	`string`[]	-
`groupBy?`	`string`	-
`bucket?`	`AppTimeUnit`	Group by calendar bucket: `groupBy` then names a declared date dimension and this is the smallest unit (see AppTimeAxis).
`transform?`	`AppTimeTransform`	Requires time buckets. Comparisons require no second grouping.
`pivotBy?`	`string`	-
`display?`	`"table"` \| `"charts"` \| `"map"` \| `"board"` \| `"timeline"` \| `"calendar"`	-
`timeField?`	`string`	Date dimension used by timeline/calendar; defaults to event.start, then the first declared date dimension. Event ends apply only to event.start.
`month?`	`string`	Calendar month in UTC, YYYY-MM; absent means the current UTC month.
`boardBy?`	`string`	Board category: a closed text enum from the collection schema.
`chart?`	`"bars"` \| `"donut"` \| `"choropleth"` \| `"scatter"`	`choropleth` colours each region of a boundary dimension (AppPresentation.properties `boundary`): `groupBy` names that dimension, with no `bucket` and no `pivotBy`.
`scatter?`	{ `x`: `string` \| `null` ; `y`: `string` \| `null` }	Scatter axes: distinct declared measures, or null for object count. Required for a scatter chart; both figures come from the same summary.
`scatter.x`	`string` \| `null`	-
`scatter.y`	`string` \| `null`	-
`measure?`	`string`	-
`sums?`	`string`[]	Up to three additional, distinct declared measures, excluding `measure`.
`within?`	`AppWithin`	A region over one of spatial_indexes, related by one of its modes: part of the query scope, so tables, charts, facets and the map all read the objects it admits (see appQueryScope). A view has at most one spatial clause, this or nearest.
`nearest?`	`AppNearest`	The `k` objects nearest a point, over a point property of spatial_indexes that ranks nearest objects: part of the query scope, and its order. A page lists them nearest first with their distances (distances); a nearest view takes no `orderBy` and no search.
`map?`	`AppMapView`	How the map presents this view; see AppMapView.

AppFavorite

Ƭ AppFavorite: { kind: "app" ; id: string } | { kind: "object" ; collection: string ; id: string } | { kind: "view" ; id: string } | { kind: "graph" ; id: string } | { kind: "map" ; id: string } One favorite in a member’s preferences: a private pointer, kept in the order it was added. It holds no title and grants nothing: every surface re-reads what it points at under the reader’s current rules, and one that no longer resolves is shown as unavailable and stays removable.

app: another app of the workspace directory, by its id.
object: an object of an exposed collection that is not a connection.
view, graph, map: a saved view, graph or map by the id AppWorkspaceState lists it under (a declared map template’s program:<id> too).

savePreferences checks an entry when it is added: an app id is 1 to 64 lowercase letters, digits or - starting with a letter, an object’s collection is exposed to the caller and its id is one of that collection’s, and a saved item’s id is one of the state table’s.

AppWorkspaceState

Ƭ AppWorkspaceState: Object Ordinary customer-owned workspace state. views and graphs hold the caller’s own saved items, then the ones other members share with every member, then the ones shared with the caller by name, each once with the caller’s AppSavedAccess (the stronger role wins). A shared item is listed only while its owner still passes the application’s authorize callback. A saved view never holds an object selection (ids): saveView refuses one, and a fixed selection is kept as a list. shared_is_complete is false when more shared views, graphs, maps or named grants exist than one read returns, or than one query checks the owners of; the most recently created or granted are listed.

Type declaration

Name	Type	Description
`person`	`string` \| `null`	The caller’s own person: an id of people, as the application’s `people.self` answers it for the signed-in caller; null when the caller is not one of its people or it declares none.
`shared_is_complete`	`boolean`	-
`views`	{ `id`: `string` ; `name`: `string` ; `view`: `AppView` ; `revision`: `number` } & `AppSavedAccess`[]	-
`graphs`	{ `id`: `string` ; `name`: `string` ; `revision`: `number` } & `AppSavedAccess`[]	The caller’s own saved graphs (at most SAVED_GRAPHS) and the graphs shared with them, without their contents: `savedGraph` reads one.
`maps`	{ `id`: `string` ; `name`: `string` ; `revision`: `number` ; `sharing`: `AppMapSharing` ; `is_owner`: `boolean` ; `can_edit`: `boolean` ; `is_template`: `boolean` ; `declared?`: `true` }[]	The caller’s own saved maps (at most `SAVED_MAPS`) then the maps other members share (newest first, bounded like shared views, each listed only while its owner passes `authorize`), without their documents: `savedMap` reads one. A template is a map with parameters.
`preferences`	{ `theme?`: `"light"` \| `"dark"` \| `"system"` ; `density?`: `"compact"` \| `"comfortable"` ; `locale?`: `string` ; `timeZone?`: `string` ; `recentObjects?`: { `collection`: `string` ; `id`: `string` }[] ; `favorites?`: `AppFavorite`[] ; `railGroups?`: `Record`<`string`, `boolean`> ; `graphStyles?`: `AppSavedGraphStyle`[] }	-
`preferences.theme?`	`"light"` \| `"dark"` \| `"system"`	-
`preferences.density?`	`"compact"` \| `"comfortable"`	Absent means compact.
`preferences.locale?`	`string`	Regional format of dates and numbers: `en` or `en-` and a region or area (`en-GB`, `en-150`); see `appIsRegionalFormat`. Interface copy is English, so the format’s language is too. Absent means the format the reader’s browser derives.
`preferences.timeZone?`	`string`	`UTC` or an IANA zone in which recorded instants are shown, at most 64 characters; see `appIsTimeZone`. Calendar dates are never shifted. Absent means the reader’s browser zone.
`preferences.recentObjects?`	{ `collection`: `string` ; `id`: `string` }[]	-
`preferences.favorites?`	`AppFavorite`[]	At most APP_FAVORITES distinct favorites in the order they were added: apps, objects, saved views, graphs and maps (see AppFavorite). Favorite apps lead the workspace’s app lists.
`preferences.railGroups?`	`Record`<`string`, `boolean`>	The member’s explicit fold choices in the workspace rail, by group id: `true` open, `false` folded; a group not listed keeps its default. At most 16 groups, each id 1 to 40 letters, digits, `-` or `_`.
`preferences.graphStyles?`	`AppSavedGraphStyle`[]	The member’s named graph styles: at most `SAVED_GRAPH_STYLES`, together at most `SAVED_GRAPH_STYLES_CHARS` encoded characters; see AppSavedGraphStyle.
`revision`	`number`	-

AppGraph

Ƭ AppGraph: Object A saved relationship graph: object identities, integer positions, edge facts and how the graph presents them — never titles, property values or row content. Reopening re-reads every node and edge under the reader’s current permissions. Its presentation is per-type styles (properties to colour, label and badge nodes by, and the date their timeline places them by), notes its owner wrote and named groups; see apps/graph. Notes are the owner’s own words, shown as written to whoever the graph is shown to. Collection and field names are stored once, in strictly increasing code-unit order, and referred to by index, so the encoding is canonical and removing a node or an edge never lengthens it. Every array is present. There is no version field: a changed shape is a hard cutover.

Type declaration

Name	Type	Description
`types`	`string`[]	Exposed collection names (1..32): node types, link types and the collections named relations are read through.
`fields`	`string`[]	Field names used by edges and styles (0..258).
`nodes`	[`number`, `string`, `number`, `number`][]	`[type, object id, x, y]`; 1..50 nodes. A node’s type is the collection it is read through; its identity is that collection’s `identity_table` and the id. Positions are integers within ±100000.
`links`	[`number`, `string`, `number`, `number`, `number`, `number`][]	`[link type, link record id, from node, from field, to node, to field]`.
`relations`	[`number`, `number`, `number`, `number`][]	`[via, from node, relation name, to node]`: a named navigation through `types[via]`. Names share the `fields` string table. These edges assert endpoint membership, without inventing an association record identity.
`hidden`	`number`[]	Sorted distinct indexes of node types hidden by the type filter (presentation only).
`styles`	`AppGraphTypeStyle`[]	Per node type: what colours, labels, badges and dates its nodes.
`notes`	`AppGraphNote`[]	Free and attached notes (at most `GRAPH_NOTES`).
`groups`	`AppGraphGroup`[]	Named groups of nodes (at most `GRAPH_GROUPS`).

AppSavedGraph

Ƭ AppSavedGraph: { id: string ; name: string ; revision: number ; graph: AppGraph } & AppSavedAccess A saved graph the caller may open: their own, or one shared with them.

AppBrowseArgs

Ƭ AppBrowseArgs: Pick<AppView, "collection" | "filters" | "analysisFilters" | "filterMode" | "groups" | "related" | "linked" | "ids" | "orderBy" | "search" | "order" | "within" | "nearest"> & { fields?: string[] ; asOf?: string ; paginationOpts: { cursor: string | null ; numItems: number ; endCursor?: string | null } }

AppAnalysis

Ƭ AppAnalysis: AppPage & { summary: AppSummary | null ; percentileSummary?: AppSummary ; basis: bigint } A page and optional grouped summary evaluated in one ordinary query. basis is that evaluation’s engine revision in nanoseconds, not source freshness or a capability to read history. Reactive clients keep results valid at their current snapshot; independent HTTP calls use new bases.

AppAnalysisArgs

Ƭ AppAnalysisArgs: Omit<AppSummaryArgs, "groupBy"> & { groupBy?: string ; paginationOpts: AppBrowseArgs["paginationOpts"] }

AppSummaryArgs

Ƭ AppSummaryArgs: Omit<AppBrowseArgs, "paginationOpts"> & { groupBy?: string ; cells?: AppCellGrouping ; bucket?: AppTimeUnit ; pivotBy?: string ; measure?: string ; sums?: string[] ; percentiles?: number[] ; top?: number }

AppFacetsArgs

Ƭ AppFacetsArgs: Omit<AppBrowseArgs, "paginationOpts"> & { histogram?: string } Facets describe the same query scope a table or chart shows, not the whole object type. The caller names an optional date dimension to bucket.

AppFacetHistogram

Ƭ AppFacetHistogram: Object A bucketed distribution of one declared date dimension over the current query scope, excluding that property’s own range predicate. Bucket bounds are UTC-aligned, closed-open, and expressed in the property’s own representation so selecting a bucket writes exactly one between predicate.

Type declaration

Name	Type
`field`	`string`
`unit`	`AppTimeUnit`
`buckets`	{ `from`: `Value` ; `to`: `Value` ; `count`: `number` }[]

AppFacetNumericHistogram

Ƭ AppFacetNumericHistogram: Object A bucketed distribution of one declared numeric dimension over the current query scope, excluding that property’s own between predicate. Buckets are closed-open, contiguous and at most 60, and every bound is a multiple of one step of 1, 2 or 5 times a power of ten, in the property’s own representation: computed on bigint for an int64, never through floating point, and for a float64 the float64 nearest that exact decimal, each checked against the values by exact comparison. Selecting a bucket writes exactly one between predicate that selects the objects it counted. min and max are the exact smallest and largest values counted. The histogram is withheld (absent) rather than rounded when no such bucketing exists: a value of another type, a non-finite float, no present value, or a bound outside the type’s range.

Type declaration

Name	Type
`field`	`string`
`min`	`bigint` \| `number`
`max`	`bigint` \| `number`
`buckets`	{ `from`: `bigint` \| `number` ; `to`: `bigint` \| `number` ; `count`: `number` }[]

AppFacets

Ƭ AppFacets: Object Counts for the current query scope. Each dimension’s count excludes that dimension’s own facet predicate, so selecting one value does not zero its siblings. path names what answered, as for AppSummary: maintained totals when every counted dimension has a covering declared aggregate and the collection has no date or numeric dimension to bucket, otherwise complete bounded native reads. When any read is incomplete no counts are returned at all and the caller falls back to the declared values.

Type declaration

Name	Type	Description
`path`	`"maintained"` \| `"bounded"` \| `"source"`	`source`: statements a virtual table’s source executed, one per dimension and histogram (AppVirtualFacets).
`is_complete`	`boolean`	-
`fields`	`Record`<`string`, { `value`: `Value` ; `count`: `bigint` }[]>	-
`uncounted`	`string`[]	Declared dimensions left uncounted because the read bound was reached.
`histogram`	`AppFacetHistogram` \| `null`	-
`numeric`	`Record`<`string`, `AppFacetNumericHistogram`>	One histogram per declared numeric dimension that was counted and could be bucketed exactly; a dimension named in `uncounted` or withheld is absent.

AppLinkRecordsArgs

Ƭ AppLinkRecordsArgs: Object

Type declaration

Name	Type	Description
`collection`	`string`	-
`id`	`string`	-
`linkCollection`	`string`	-
`endpointField`	`string`	-
`where?`	`AppFilter`[]	Filters on the link record’s own properties, all of which must match.
`paginationOpts`	{ `cursor`: `string` \| `null` ; `numItems`: `number` }	-
`paginationOpts.cursor`	`string` \| `null`	-
`paginationOpts.numItems`	`number`	-

AppNoticeRoute

Ƭ AppNoticeRoute: Object Where a page notice opens: the route parameters of that workspace page, the same ones its own links carry. tab is a kebab-case identifier; every other value is an opaque non-empty string the page interprets (an item id, an encoded view), at most APP_NOTICE_ROUTE_MAX characters.

Type declaration

Name	Type
`id?`	`string`
`tab?`	`string`
`detail?`	`string`
`collection?`	`string`
`view?`	`string`
`graph?`	`string`

AppNoticeSubject

Ƭ AppNoticeSubject: { kind: "object" ; collection: string ; id: string ; title: string ; tab?: string ; detail?: string } | { kind: "page" ; page: string ; route: AppNoticeRoute ; title: string } What a delivered notice is about, resolved under the reader’s current reads.

object: an object of an exposed collection, titled by its title property. tab names the object view tab the notice opens, and detail the item on it (the event itself, for a collection-backed category that declares a tab).
page: a workspace page, a feature destination or a native page, by its kebab-case id, with the route it opens and a title its category resolved.

AppNotification

Ƭ AppNotification: Object A delivered notice resolves its content under current object permissions. event is the occurrence reference its category resolves; a category and an event identify one occurrence.

Type declaration

Name	Type
`id`	`string`
`kind`	`string`
`label`	`string`
`message`	`string`
`event`	`string`
`subject`	`AppNoticeSubject`
`created_at`	`number`
`is_read`	`boolean`
`is_archived`	`boolean`

AppNotificationPage

Ƭ AppNotificationPage: Object A page may hold fewer notifications than requested while isDone is false: resolving each notification’s event and object counts against the query’s read bound (end: "budget", at most 32 rows per query), and unavailable targets are omitted. Continue from continueCursor; no notification is skipped.

Type declaration

Name	Type	Description
`page`	`AppNotification`[]	-
`isDone`	`boolean`	-
`continueCursor`	`string`	-
`end`	`AppPageEnd`	-
`withheld`	`number`	Rows of this page delivered to the reader that no longer resolve through their current reads (the event is withheld from them now, as when a clearance is withdrawn, or it is gone): left out, counted here, nothing else said about them.

AppRequestablePermission

Ƭ AppRequestablePermission: "invoke" | "preview" The permissions a member may request on an operation they can see. read is the precondition of asking; reviewer authority (grant) is set only by a deployment administrator.

AppAccessRequestStatus

Ƭ AppAccessRequestStatus: "pending" | "approved" | "rejected" | "withdrawn" Where an access request stands; every status but pending is final.

AppAccessRequestPerson

Ƭ AppAccessRequestPerson: Object A person as an access request names them. label is a display snapshot of their sign-in claims, never identity.

Type declaration

Name	Type
`label`	`string`
`is_you`	`boolean`

AppAccessRequest

Ƭ AppAccessRequest: Object One access request as a caller who may see it reads it: their own, or one on an operation they currently hold reviewer authority for.

Type declaration

Name	Type	Description
`id`	`string`	-
`component?`	`string`	The installed component exactly as the app exposes the operation; absent for a root operation.
`operation`	`string`	Canonical `module.js:export`, as the operation’s contract names it.
`permission`	`AppRequestablePermission`	-
`reason`	`string`	-
`requester`	`AppAccessRequestPerson`	-
`requested_at`	`number`	When the request was recorded, epoch milliseconds.
`updated_at`	`number`	The engine revision of the latest transition, epoch milliseconds.
`status`	`AppAccessRequestStatus`	-
`decision`	`null` \| { `reviewer`: `AppAccessRequestPerson` ; `comment`: `string` }	Present for `approved` and `rejected`.
`is_acknowledged`	`boolean`	For the requester: whether they have opened the decision. Always true for anyone else.
`can_decide`	`boolean`	The caller holds reviewer authority now, is not the requester, and the request is pending. The decision is rechecked when it is submitted.

AppAccessRequestPage

Ƭ AppAccessRequestPage: Object The access requests one caller may see among the app’s exposed operations: every pending one first, then the newest decided ones, at most 200. Nothing here is a total beyond what was read.

Type declaration

Name	Type	Description
`requests`	`AppAccessRequest`[]	Newest first.
`pending_complete`	`boolean`	Every pending request this caller may see was read.
`decided_complete`	`boolean`	Every decided request this caller may see was read; usually false, because only the newest decided requests are read.
`unseen_complete`	`boolean`	Every decision on the caller’s own requests that they have not opened was read, however old. With `pending_complete`, the caller’s attention count is exact.
`reviewable`	{ `component?`: `string` ; `operation`: `string` }[]	Exposed operations whose requests this caller may decide.

AppAccessRequestAction

Ƭ AppAccessRequestAction: { action: "resource" ; requests: { component?: string ; table: string } ; update: ResourceAccessRequestUpdate } | { action: "create" ; operation: { component?: string ; operation: string } ; permission: AppRequestablePermission ; reason: string } | { action: "withdraw" ; id: string } | { action: "acknowledge" ; id: string } | { action: "decide" ; id: string ; decision: "approve" | "reject" ; comment: string } The one write into access requests, sent to the deployment’s native POST /api/access_requests with the caller’s own token. No function runs in that path, so no program can file or decide a request on someone’s behalf; the engine rechecks the request’s state and the caller’s current authority, and an approval writes exactly the requested grant.

ResourceAccessRequestUpdate

Ƭ ResourceAccessRequestUpdate: { action: "create" ; resource: ResourceAccess ; reason: string } | { action: "decide" ; id: string ; decision: "approve" | "reject" ; comment: string } | { action: "withdraw" ; id: string } | { action: "acknowledge" ; id: string } Native writes for the access model’s declared resource request table. beneficiary is the workspace person ID; signing in grants no role.

AppAccessRequestReceipt

Ƭ AppAccessRequestReceipt: Object What an accepted access request write answers.

Type declaration

Name	Type	Description
`id`	`string`	-
`status`	`AppAccessRequestStatus`	-
`assignmentId?`	`string`	The assignment an approved resource request wrote.

ResourceRequestsTable

Ƭ ResourceRequestsTable: Object The access model’s declared requests table, and its component when a component’s model declares it.

Type declaration

Name	Type
`component?`	`string`
`table`	`string`

AppIntegrationFailureReason

AppSourceCause

AppPostgresBlockReason

AppPreparation

Ƭ AppPreparation: Object One unpublished preparation of a relation: closed words and two engine revisions. A refusal’s reason is withheld.

Type declaration

Name	Type	Description
`owner`	`"source"` \| `"materialized_view"` \| `"published"`	-
`state`	`"open"` \| `"sealed"` \| `"validating"` \| `"validated"` \| `"refused"`	-
`recorded_at`	`bigint`	Engine revision (nanosecond commit timestamp) at which this preparation was declared.
`progressed_at`	`bigint`	Engine revision of its last recorded progress.

AppDependencySource

Ƭ AppDependencySource: Object One installed source of a source-owned table, as its rows’ readers may see it. Wall-clock instants are exact epoch milliseconds; published_at is an engine revision. None of them is business valid time, and none proves the source has no newer changes.

Type declaration

Name	Type	Description
`source`	`string`	Stable source handle under the same row authority as this status.
`generation`	`bigint` \| `null`	Current connection ownership fence; null if replaced.
`contract_revision`	`string`	-
`health`	`AppSourceHealthHistory` \| `null`	Retained, collection-filtered evidence from the installed monitoring product.
`dataset`	`NonNullable`<`SourceCoverage`[`"dataset"`]> \| `null`	Exact served dataset basis, under this source’s row authority; null for another transport or a replaced source. Preparation leaves serving intact.
`ordinal`	`number`	Position in this response, not an identity.
`population_covered`	`boolean`	Qualified evidence covers the serving population. `false` leaves completeness unknown, including after a visible partial successor.
`observed_from`	`bigint` \| `null`	Observation window of the current coverage, as the engine recorded it around its contacts with the source. Not proof of currency; compare sources by `published_at`.
`observed_to`	`bigint` \| `null`	Advances on an unchanged revalidation as well as on a publication.
`published_at`	`bigint` \| `null`	Engine revision of the latest coverage publication; the only instant comparable across sources.
`continuity_lost`	`boolean`	-
`erased`	`boolean`	This source’s imported rows were erased; its coverage no longer answers for rows.
`checked_at`	`bigint` \| `null`	Last check this source’s refresh owner answered successfully (epoch ms). Transport success only, not proof of currency.
`refresh_outstanding`	`boolean`	-
`is_unreachable`	`boolean`	The last recorded contact attempt failed.
`replaced`	`boolean`	The connection this source was installed under has been reconfigured. The coverage above describes what the source observed before; `schedule` and `stream` are then null because they would describe the new connection’s work.
`schedule`	`null` \| { `state`: `"scheduled"` \| `"pending"` \| `"retrying"` \| `"blocked"` \| `"paused"` ; `reason`: `AppIntegrationFailureReason` \| `null` ; `cause`: `AppSourceCause` \| `null` }	null: no integration schedule record, or `replaced`.
`stream`	`null` \| { `phase`: `"uninitialized"` \| `"creating"` \| `"streaming"` \| `"blocked"` ; `readiness`: `"loading"` \| `"validating"` \| `"published"` \| `"catching_up"` \| `"live"` \| `"blocked"` ; `block_reason`: `AppPostgresBlockReason` \| `null` ; `publication_failure`: `"required_view"` \| `"admission"` \| `"capacity"` \| `null` ; `is_preparing`: `boolean` }	The PostgreSQL stream this source reads through, shared by every member of its coupled group: facts about the shared stream, never about this source alone. null: a transport this status does not report, no verified group membership, or `replaced`.

AppDependencyStatus

Ƭ AppDependencyStatus: Object Status of one exposed collection’s declared dependencies, read under the demands of the rows it describes. A caller who may not read those rows receives the engine’s Read access was refused instead of a result.

Type declaration

Name	Type	Description
`collection`	`string`	-
`kind`	`"table"` \| `"view"` \| `"source"` \| `"published"` \| `"virtual_table"`	-
`sources`	`null` \| { `items`: `AppDependencySource`[] ; `is_complete`: `boolean` }	Present exactly when `kind` is `source`.
`publication`	`null` \| { `served_revision`: `bigint` \| `null` ; `evidence`: `AppPublicationInputEvidence` \| `null` ; `preparations`: `AppPreparation`[] ; `is_complete`: `boolean` }	Present when `kind` is `source`, `published`, or a materialized `view`.
`object_source`	`number` \| `null`	1-based ordinal (within `sources.items`) of the source the requested object was acquired from; null when no object was requested, it carries no source, or its source is not among the disclosed items.

AppSyncRun

Ƭ AppSyncRun: Object One sync of a source: one scheduled occurrence of its acquisition, with what it ADMITTED (never a diff of the served table). Counts and instants are exact bigints; started_at, ended_at and observed_to are epoch milliseconds and published_at is an engine revision.

Type declaration

Name	Type	Description
`run`	`string`	Opaque and stable for the run; not a request id.
`origin`	`"scheduled"` \| `"manual"` \| `"notification"` \| `"reconciliation"` \| `"repair"`	-
`state`	`"running"` \| `"retrying"` \| `"blocked"` \| `"completed"` \| `"cancelled"`	-
`reason`	`AppIntegrationFailureReason` \| `null`	The classified failure of a retrying or blocked run, only when every source of its coupled group is disclosed in this answer; else null.
`started_at`	`bigint`	-
`ended_at`	`bigint` \| `null`	-
`pages`	`bigint`	-
`requests`	`bigint`	-
`response_bytes`	`bigint`	-
`records`	`bigint`	-
`claims`	`bigint`	-
`failed_attempts`	`bigint`	-
`published_at`	`bigint` \| `null`	Set only when the run moved the source’s coverage.
`observed_to`	`bigint` \| `null`	-

AppAcquisitionHistory

Ƭ AppAcquisitionHistory: Object A component-retained acquisition report window; sequences are exact and missing native observations or product retention never imply completeness.

Type declaration

Name	Type
`generation`	`bigint`
`contract_revision`	`string`
`oldest_sequence`	`bigint`
`through_sequence`	`bigint`
`next_sequence`	`bigint`
`is_complete`	`boolean`
`has_gap`	`boolean`
`runs`	{ `sequence`: `bigint` ; `run`: `AppSyncRun` }[]

AppConnectionCheck

Ƭ AppConnectionCheck: Object A connection’s check as one reader may see it: the last result for the connection’s current configuration, and when the reader’s OWN pending request was made. Nobody learns of another person’s request.

Type declaration

Name	Type	Description
`state`	`"confirmed"` \| `"identity_differs"` \| `"unverified"` \| `"failed"` \| `null`	-
`checked_at`	`bigint` \| `null`	Epoch milliseconds of the last result.
`reason`	`AppIntegrationFailureReason` \| `null`	-
`pending_since?`	`bigint` \| `null`	Epoch milliseconds of the caller’s own unexecuted request.

AppSourceRuns

Ƭ AppSourceRuns: Object One installed source of a synced collection with its syncs.

Type declaration

Name	Type	Description
`source`	`string`	The source’s handle: the value its rows carry as `source_id`.
`status`	`AppDependencySource`	-
`records_runs`	`boolean`	false: this source’s schedule was retired (a reconfigured connection’s predecessor); it records no more syncs and cannot be synced.
`open`	`AppSyncRun` \| `null`	-
`latest`	`AppSyncRun` \| `null`	-
`history`	`AppAcquisitionHistory` \| `null`	Retained reporting from the installed source-health component. Native open/latest facts remain available without this product.
`check`	`AppConnectionCheck` \| `null`	-
`refresh`	{ `pending`: `boolean` ; `pending_records`: `bigint` \| `null` ; `pending_collection`: `boolean` ; `active_collection`: `boolean` ; `active_records`: `bigint` \| `null` ; `oldest_pending_at`: `bigint` \| `null` } \| `null`	Accepted refresh work, disclosed as counts and age under this source’s row authority. Record keys and notification identities stay private. null for a reconfigured connection’s predecessor.

AppSourceRunsPage

Ƭ AppSourceRunsPage: Object The sync history of one synced collection, read under the same demands as its AppDependencyStatus: a caller who may not read its rows receives the engine’s Read access was refused instead of a result.

Type declaration

Name	Type
`collection`	`string`
`sources`	{ `items`: `AppSourceRuns`[] ; `is_complete`: `boolean` }
`sources.items`	`AppSourceRuns`[]
`sources.is_complete`	`boolean`

AppSourceRefreshReceipt

Ƭ AppSourceRefreshReceipt: SourceControlReceipt & { outcome: Extract<SourceControlOutcome, { kind: "requested" | "joined" }> } The immutable acceptance of an application refresh action.

AppConnectionCheckRequest

Ƭ AppConnectionCheckRequest: Object A recorded connection check request, bound to the caller. Execute it with runConnectionCheck.

Type declaration

Name	Type
`request`	`string`

AppConnectionCheckResult

Ƭ AppConnectionCheckResult: Object A connection check’s result. checked_at is epoch milliseconds.

Type declaration

Name	Type
`state`	`"confirmed"` \| `"identity_differs"` \| `"unverified"` \| `"failed"`
`checked_at`	`number`
`reason`	`AppIntegrationFailureReason` \| `null`

AppResourceRef

Ƭ AppResourceRef: Extract<ResourceRef, `collection:

\{string}\` \| \`operation:

{string}` | `function:

\{string}\`\> \| \`producer:

{string}` | `capability:${string}` A deployment-relative address. References never convey read or execution authority.

AppResourceField

Ƭ AppResourceField: Object

Type declaration

Name	Type
`resource`	`AppResourceRef`
`field`	`string`

AppResourceRow

Ƭ AppResourceRow: Object

Type declaration

Name	Type
`resource`	`collection:${string}`
`object`	`string`

AppResourceCell

Ƭ AppResourceCell: AppResourceRow & { field: string }

AppHealthOutcome

Ƭ AppHealthOutcome: "passed" | "failed" | "unknown"

AppHealthDimension

AppHealthAssessment

Ƭ AppHealthAssessment: Object

Type declaration

Name	Type
`objective_key`	`string`
`dimension`	`AppHealthDimension`
`outcome`	`AppHealthOutcome`
`configuration`	`"configured"` \| `"unconfigured"` \| `"unknown"`
`source`	`string` \| `null`
`evaluated_at`	`bigint` \| `null`
`next_evaluation_at`	`bigint` \| `null`
`reason`	{ `code`: `string` ; `message`: `string` }
`reason.code`	`string`
`reason.message`	`string`
`evidence`	`AppHealthEvidence`[]

AppHealthEvidence

Ƭ AppHealthEvidence: { kind: "source_status" ; source: string ; checked_at: bigint } | { kind: "health_observation" ; source: string ; sequence: bigint ; generation: bigint ; contract_revision: string } | { kind: "expectation_verdict" ; source: string ; objective_key: string ; definition_digest: string ; revision: string } | { kind: "publication" ; revision: string }

AppSourceHealthObservation

Ƭ AppSourceHealthObservation: Object A source-owner observation, released only for the requested collection.

Type declaration

Name	Type
`sequence`	`bigint`
`generation`	`bigint`
`contract_revision`	`string`
`checked_at`	`bigint`
`freshness`	{ `state`: `"not_configured"` \| `"unknown"` \| `"fresh"` \| `"stale"` ; `objective_ms`: `bigint` \| `null` ; `observed_from`: `bigint` \| `null` ; `next_evaluation_at`: `bigint` \| `null` } \| `null`
`quality`	{ `state`: `"not_configured"` \| `"unknown"` \| `"passed"` \| `"failed"` ; `checks`: { `key`: `string` ; `definition_digest`: `string` ; `consequence`: `"blocking"` \| `"advisory"` ; `outcome`: `"passed"` \| `"failed"` \| `"unknown"` ; `verdict_revision`: `string` \| `null` }[] ; `blocking_failures`: `number` ; `advisory_failures`: `number` ; `is_complete`: `boolean` } \| `null`

AppSourceHealthHistory

Ƭ AppSourceHealthHistory: Object

Type declaration

Name	Type	Description
`observations`	`AppSourceHealthObservation`[]	-
`current_observation`	`AppSourceHealthObservation`	-
`is_complete`	`boolean`	False when older observations have expired. Never a claim of lifetime history.
`has_gap`	`boolean`	-
`retained_from`	`bigint`	-
`retained_to`	`bigint`	-
`through_sequence`	`bigint`	-
`next_sequence`	`bigint` \| `null`	-
`generation`	`bigint`	-
`contract_revision`	`string`	-

AppHealthArgs

Ƭ AppHealthArgs: AppInspectionArgs & { source?: string ; after_sequence?: bigint ; through_sequence?: bigint ; generation?: bigint ; contract_revision?: string ; limit?: number }

AppResourceHealth

Ƭ AppResourceHealth: Object

Type declaration

Name	Type
`resource`	`AppResourceSummary`
`context`	`AppInspectionContext`
`assessments`	`AppHealthAssessment`[]
`sources`	`AppDependencyStatus`[`"sources"`]

AppResourceMonitorLiveness

Ƭ AppResourceMonitorLiveness: Object A fresh server-side probe of retained monitor progress, not a source reading.

Type declaration

Name	Type
`resource`	`AppResourceRef`
`key`	`string`
`state`	`"stalled"` \| `"pending"` \| `"no_pending_evidence"` \| `"unknown"` \| `"not_installed"`
`outcome`	`"failed"` \| `"unknown"` \| `"not_applicable"`
`checked_at`	`bigint`
`pending_since`	`bigint` \| `null`
`reconciled_at`	`bigint` \| `null`
`deadline_at`	`bigint` \| `null`
`objective_ms`	`number`

AppResourceEdge

Ƭ AppResourceEdge: Object

Type declaration

Name	Type
`from`	`AppResourceRef`
`to`	`AppResourceRef`
`kind`	`"derives"` \| `"publishes"` \| `"acts_on"` \| `"consumes"` \| `"offers"` \| `"uses"`
`evidence`	`"admitted"` \| `"declared"` \| `"recorded"` \| `"reported"`
`fields`	`string`[]

AppResourceUsage

Ƭ AppResourceUsage: Object Consumer declarations supplement compiler-derived dependencies; they attest no runtime read.

Type declaration

Name	Type	Description
`resource`	`AppResourceRef`	-
`consumer`	`AppResourceRef`	-
`fields?`	readonly `string`[]	-
`field_mappings?`	readonly { `input_field`: `string` ; `output_field`: `string` }[]	Input/output field paths on a producer’s admitted declaration; never a runtime read claim.

AppInspectionMetadata

Ƭ AppInspectionMetadata: Object Operational documentation. These roles and links grant no authority.

Type declaration

Name	Type
`responsible_role?`	`string`
`documentation_url?`	`string`
`runbook_url?`	`string`
`tags?`	`string`[]
`deprecation?`	{ `message`: `string` ; `replacement?`: `AppResourceRef` }
`deprecation.message`	`string`
`deprecation.replacement?`	`AppResourceRef`

AppResourceSummary

Ƭ AppResourceSummary: Object

Type declaration

Name	Type	Description
`id`	`string`	Deployment-scoped identity. Collections use their native lifetime ID; authored exports and installations use their admitted declaration key.
`ref`	`AppResourceRef`	-
`kind`	`string`	-
`name`	`string`	-
`label`	`string`	-
`description`	`string` \| `null`	-
`metadata`	`AppInspectionMetadata` \| `null`	-

AppInspectionContext

Ƭ AppInspectionContext: Object

Type declaration

Name	Type	Description
`definition_digest`	`string`	Digest of the currently authorized definition projection, not an engine revision.

AppInspectionArgs

Ƭ AppInspectionArgs: Object

Type declaration

Name	Type	Description
`ref`	`AppResourceRef`	-
`expected_id?`	`string`	Refuse a same-address replacement. Prefer passing a resource summary to the query builder.
`context?`	`AppInspectionContext`	-

AppPipelineVersionSelection

Ƭ AppPipelineVersionSelection: Object

Type declaration

Name	Type
`version_id`	`string`

AppPublicationInputEvidence

Ƭ AppPublicationInputEvidence: { kind: "unknown" ; reason: "not_published" | "not_retained" | "not_certified" } | { kind: "captured_inputs" ; inputs: { resource: AppResourceRef ; read_revision: string ; scope: "collection" | "source" ; observed_from: string | null ; observed_to: string | null }[] ; is_complete: boolean } Evidence retained by the publication owner with the output commit. Captured inputs attest neither the producer’s actual reads nor row contributions.

AppRecordedLineage

Ƭ AppRecordedLineage: Object

Type declaration

Name	Type
`selection`	`AppPipelineVersionSelection`
`reader`	`function:${string}`
`version_id`	`string`
`definition_digest`	`string`
`execution_id`	`string`
`execution_ordinal`	`number`
`input_versions`	`string`[]
`observations`	{ `resource`: `AppResourceRef` ; `source`: `string` \| `null` ; `observed_at`: `bigint` \| `null` }[]
`declared_inputs`	`AppResourceRef`[]
`reported_relationships`	{ `resource`: `AppResourceRef` ; `external_run_id`: `string` ; `direction`: `string` ; `version`: `string` \| `null` }[]
`is_complete`	`boolean`

AppExplainSelection

Ƭ AppExplainSelection: { kind: "publication" } | { kind: "versions" ; cursor?: string } | { kind: "pipeline_version" ; selection: AppPipelineVersionSelection } | { kind: "field" ; field: string } | { kind: "health_observation" ; source: string ; sequence: bigint ; generation: bigint ; contract_revision: string }

AppNativeExplainSelection

Ƭ AppNativeExplainSelection: { kind: "value" ; object: string ; field: string ; revision?: string } | { kind: "view_row" ; object: string ; revision?: string } Native provenance pins an engine revision independently of definition context.

AppNativeExplanation

Ƭ AppNativeExplanation: Object

Type declaration

Name	Type	Description
`format_version`	`number`	-
`resource`	`AppResourceRef`	-
`context`	`AppInspectionContext`	-
`status`	`"explained"` \| `"indeterminate"` \| `"refused"` \| `"incomplete"`	-
`reasons`	`string`[]	-
`basis`	{ `revision`: `string` ; `scope?`: `string` ; `component?`: `string` }	-
`basis.revision`	`string`	-
`basis.scope?`	`string`	-
`basis.component?`	`string`	-
`detail?`	`unknown`	Owner-native JSON evidence. Exact revisions remain decimal strings.
`unproved?`	`string`[]	-
`contribution_revision?`	`string` \| `null`	Result membership and positive input rows at the contribution basis.
`contributions?`	{ `is_member`: `boolean` \| `null` ; `contributors`: { `table`: `string` ; `object`: `string` }[] ; `is_complete`: `boolean` ; `reasons`: `string`[] } \| `null`	-

AppExplainArgs

Ƭ AppExplainArgs: AppInspectionArgs & { explanation: AppExplainSelection }

AppResourceExplanation

Ƭ AppResourceExplanation: { kind: "versions" ; resource: AppResourceSummary ; context: AppInspectionContext ; items: { selection: AppPipelineVersionSelection ; execution_id: string ; execution_ordinal: number ; definition_digest: string }[] ; next_cursor: string | null } | { kind: "publication" ; resource: AppResourceSummary ; context: AppInspectionContext ; served_revision: string | null ; evidence: AppPublicationInputEvidence ; unproved: string[] } | { kind: "pipeline_version" ; resource: AppResourceSummary ; context: AppInspectionContext ; lineage: AppRecordedLineage } | { kind: "field" ; resource: AppResourceSummary ; context: AppInspectionContext ; trace: AppFieldTrace } | { kind: "health_observation" ; resource: AppResourceSummary ; context: AppInspectionContext ; source: string ; observation: AppSourceHealthObservation }

AppLineageArgs

Ƭ AppLineageArgs: AppInspectionArgs & { direction?: "upstream" | "downstream" | "both" ; field?: string ; limit?: number ; cursor?: string ; mode?: "declared" | "usage" | "recorded" ; selection?: AppPipelineVersionSelection ; to?: AppResourceRef }

AppInspectionCapability

Ƭ AppInspectionCapability: { is_supported: true } | { is_supported: false ; reason: "unsupported_resource" | "evidence_not_recorded" }

AppResourceInspection

Ƭ AppResourceInspection: Object

Type declaration

Name	Type	Description
`resource`	`AppResourceSummary`	-
`context`	`AppInspectionContext`	-
`definition`	`AppCollection` \| `AppCatalog`[`"operations"`][`number`] \| `AppCatalog`[`"features"`][`number`] \| `AppCatalog`[`"callables"`][`number`]	-
`capabilities`	{ `health`: `AppInspectionCapability` ; `health_history`: `AppInspectionCapability` ; `value_explanation`: `AppInspectionCapability` ; `view_row_explanation`: `AppInspectionCapability` ; `column_lineage`: `AppInspectionCapability` ; `recorded_lineage`: `AppInspectionCapability` }	-
`capabilities.health`	`AppInspectionCapability`	-
`capabilities.health_history`	`AppInspectionCapability`	-
`capabilities.value_explanation`	`AppInspectionCapability`	-
`capabilities.view_row_explanation`	`AppInspectionCapability`	-
`capabilities.column_lineage`	`AppInspectionCapability`	-
`capabilities.recorded_lineage`	`AppInspectionCapability`	-
`status`	`AppDependencyStatus` \| `null`	The owner’s current status. Null means unsupported, never healthy.
`health`	`AppHealthAssessment`[]	-

AppResourceLineage

Ƭ AppResourceLineage: Object

Type declaration

Name	Type	Description
`context`	`AppInspectionContext`	-
`mode`	`"declared"` \| `"usage"` \| `"recorded"`	-
`recorded`	`AppRecordedLineage` \| `null`	-
`nodes`	`AppResourceSummary`[]	-
`edges`	`AppResourceEdge`[]	-
`columns`	`NonNullable`<`AppCollection`[`"view"`]>[`"columns"`] \| `null`	-
`field_trace`	`AppFieldTrace` \| `null`	-
`next_cursor`	`string` \| `null`	-
`is_complete`	`boolean`	-
`boundary`	`"authorized_catalog"`	Completeness is relative to the caller’s authorized catalog.
`traversal_complete`	`boolean`	-
`field_trace_complete`	`boolean`	-
`stop_reason`	`"work_bound"` \| `null`	-

AppFieldTrace

Ƭ AppFieldTrace: Object

Type declaration

Name	Type
`direction`	`"upstream"` \| `"downstream"`
`edges`	{ `from`: `AppResourceField` ; `to`: `AppResourceField` ; `role`: `"value"` \| `"membership"` \| `"ordering"` ; `derivation`: `string` ; `evidence`: `"admitted"` \| `"declared"` }[]
`stops`	{ `at`: `AppResourceField` ; `reason`: `"source"` \| `"producer"` \| `"application"` \| `"consumer"` \| `"not_reported"` \| `"bound"` }[]
`is_complete`	`boolean`

AppInspectionSelection

Ƭ AppInspectionSelection: AppExplainSelection | AppNativeExplainSelection | { kind: "lineage" ; mode: "declared" | "usage" | "recorded" ; direction: "upstream" | "downstream" | "both" ; field?: string ; to?: AppResourceRef ; selection?: AppPipelineVersionSelection }

InspectionQuery

Ƭ InspectionQuery: { kind: "inspect" ; args: AppInspectionArgs } | { kind: "lineage" ; args: AppLineageArgs } | { kind: "health" ; args: AppHealthArgs } | { kind: "explain" ; args: AppExplainArgs } | { kind: "explain" ; args: AppInspectionArgs & { explanation: AppNativeExplainSelection } } Pure descriptions of inspection reads. A selection carries no authority.

InspectionValue

Ƭ InspectionValue<Query>: Query extends { args: { explanation: AppNativeExplainSelection } } ? AppNativeExplanation : { inspect: AppResourceInspection ; lineage: AppResourceLineage ; health: AppResourceHealth ; explain: AppResourceExplanation }[Query["kind"]]

Type parameters

Name	Type
`Query`	extends `InspectionQuery`

WatchableInspectionQuery

Ƭ WatchableInspectionQuery: Exclude<InspectionQuery, { args: { explanation: AppNativeExplainSelection } }> Current application evidence can be watched. Native value proofs select an immutable revision and use an explicit read.

Resource

Ƭ Resource: AppResourceRef | { ref: AppResourceRef ; id?: string } Not exported: an exported type refers to it.

AppLineageRef

Ƭ AppLineageRef: { kind: "collection" ; name: string } | { kind: "producer" ; name: string } | { kind: "operation" ; operation: string ; component?: string } | { kind: "capability" ; id: string } A node a capability report names. A collection is named by its exposed name (a capability naming one of its own inputs by a table name the application does not expose is not drawn), a producer by its published producer name, an operation by its contract’s module:export (and the declaring component, for a component operation), and a capability by its exposed feature id.

AppLineageNodeState

Ƭ AppLineageNodeState: Object What a capability reports about one node it owns. label is the word drawn on the node and title the sentence behind it. build puts the state in the Build colouring. staleness puts it in the Staleness colouring: stale only for a declared freshness target the capability evaluated and found missed, pending for recorded outstanding work. A report never states that data is current.

Type declaration

Name	Type
`label`	`string`
`intent`	`AppIntent`
`title`	`string`
`build`	`boolean`
`staleness`	`"stale"` \| `"pending"` \| `null`

AppLineageReport

Ƭ AppLineageReport: Object One capability’s lineage report. restricted counts the capability’s own nodes the caller may not read, which are left out rather than drawn empty; isComplete is false when the capability left anything else out.

Type declaration

Name	Type
`states`	{ `node`: `AppLineageRef` ; `state`: `AppLineageNodeState` }[]
`edges`	{ `from`: `AppLineageRef` ; `to`: `AppLineageRef` ; `label`: `string` }[]
`restricted`	`number`
`isComplete`	`boolean`

AppColumnRef

Ƭ AppColumnRef: Object A field of an exposed collection a view reads directly.

Type declaration

Name	Type
`collection`	`string`
`field`	`string`

AppColumnDerivation

AppViewColumn

Ƭ AppViewColumn: Object One output field of a view with an explicit derivation, and the fields of exposed inputs it reads, sorted (at most 8). A field of an input the application does not expose is never named; from may then be empty.

Type declaration

Name	Type
`field`	`string`
`derivation`	`AppColumnDerivation`
`from`	`AppColumnRef`[]

AppColumnPassthrough

Ƭ AppColumnPassthrough: { collection: string ; under: string | null } | { collection: null ; under: string } Every field of an input appears in the view unchanged: at the top level (under: null) or beneath the named output field. An input this reader cannot see is never named: one passed through beneath an output field keeps only that field (collection: null), which the view’s own fields already show, so its fields are never read as another input’s; one passed through at the top level is not listed.

AppViewColumns

Ƭ AppViewColumns: Object A view’s declared column lineage, derived by the engine from the admitted declaration and restricted to the inputs this reader can see: it never names an unexposed table or a collection withheld from the reader (by discovery admission or the application’s readable), and never a filter’s literal values. It is what the declaration says, not which input rows contributed to a value. A scan of another view stops at that view, which is an input collection of its own.

Type declaration

Name	Type	Description
`items`	`AppViewColumn`[]	Output fields with an explicit derivation, by name (at most 64).
`passthrough`	`AppColumnPassthrough`[]	-
`rows`	`AppColumnRef`[]	Exposed input fields that decide row membership: filter predicates and join keys (at most 64).
`ordering`	`AppColumnRef`[]	Fields that order results or select rows within a window (at most 64).
`is_complete`	`boolean`	False when a bound cut what the exposed inputs would show.

AppLineageMode

Ƭ AppLineageMode: "data" | "workflow" Which tab of the Dependencies page a lineage shows.

AppLineageColour

Ƭ AppLineageColour: "issues" | "build" | "staleness" How a lineage colours its nodes.

AppLineage

Ƭ AppLineage: Object A saved lineage: the Dependencies page as its member left it. subject is an exposed collection, or null for the whole application; focus is the selected node’s id (see appLineageNodeId; integrations are integration:<integration>/<collection>); search is the search text.

Type declaration

Name	Type
`subject`	`string` \| `null`
`mode`	`AppLineageMode`
`colour`	`AppLineageColour`
`focus`	`string` \| `null`
`search`	`string`

AppSavedLineage

Ƭ AppSavedLineage: Object A saved lineage with current workspace sharing access.

Type declaration

Name	Type	Description
`id`	`string`	-
`name`	`string`	-
`revision`	`number`	-
`lineage`	`AppLineage`	-
`access?`	`AppSavedAccess`	Present for shared records; absent for an owner-only listing.

AppRenderBox

Ƭ AppRenderBox: Object A box in WGS84 degrees. west > east crosses the antimeridian: it is read as its two halves.

Type declaration

Name	Type
`west`	`number`
`south`	`number`
`east`	`number`
`north`	`number`

AppMapLayerObjectsArgs

Ƭ AppMapLayerObjectsArgs: Object

Type declaration

Name	Type	Description
`map`	`string`	-
`layer`	`string`	-
`box`	`AppRenderBox` \| `null`	-
`asOf?`	`string`	The UTC day (`YYYY-MM-DD`) a scope with relative date ranges is read on; required exactly when the scope holds one.

AppMapLayerObjects

Ƭ AppMapLayerObjects: { kind: "objects" ; map: { id: string ; name: string ; revision: number } ; layer: AppMapLayer ; collection: AppCatalog["collections"][number] ; objects: AppObject[] } | { kind: "refused" ; code: "unauthenticated" | "forbidden" | "not_found" | "unrenderable" | "too_large" ; message: string } The layer, its object type as the caller’s catalog lists it, and every object of its scope the caller may read (each once, in scope order), or the refusal of a request the render cannot answer: unauthenticated (no signed-in caller), forbidden (the program’s authorization refuses the caller), not_found (a saved map the caller may not open, answered as savedMap answers it whether or not it exists; no such layer; or its object type is not readable), unrenderable (not an objects layer, a template’s parameters, a field that is not drawn geometry, a box beside a scope that cannot take one) or too_large (more than MAP_RENDER_OBJECTS objects or MAP_RENDER_BYTES, or past one query’s read budget). Every refusal is data, so a caller such as an HTTP action reads its reason whatever the engine withholds of a thrown error.

AppMapTile

Ƭ AppMapTile: { data: ArrayBuffer ; contentType: string } | { refused: string } | null What the mapTile action answers a member: the tile’s bytes and content type; null when the provider has no tile there (drawn transparent); or why this tile cannot be served (the basemap is not one the deployment serves, there is no such tile, the key is not configured, or the provider failed or answered something else than one raster image of at most APP_MAP_TILE_BYTES), never naming the provider’s URL or key.

AppBasemap

Ƭ AppBasemap: { kind: "none" } | { kind: "raster" ; tiles: string ; tileSize: 256 | 512 ; maxZoom: number ; attribution: string ; license: string } | { kind: "style" ; url: string ; attribution: string ; license: string } A background map. none draws data on a plain background and needs no network; raster is an XYZ tile template; style a MapLibre style document URL.

AppBasemapOption

Ƭ AppBasemapOption: Object One basemap a member may choose.

Type declaration

Name	Type	Description
`id`	`string`	1 to 40 of `[A-Za-z0-9_-]`, unique among the options.
`label`	`string`	1 to 80 characters.
`basemap`	`AppBasemap`	-
`keyEnv?`	`string`	Deployment environment variable holding the provider key; tiles are then fetched by the `mapTile` action, never by the browser. Only a program’s raster option declares one. The variable holds the query parameter the provider takes, `name=value` (for example `key=...` or `access_token=...`), which the action appends to the tile URL.

AppOverlaySource

Ƭ AppOverlaySource: { kind: "geojson" ; data: string } | { kind: "geojsonUrl" ; url: string } | { kind: "vectorTiles" ; tiles: string ; sourceLayer: string ; minzoom: number ; maxzoom: number ; attribution: string } | { kind: "rasterTiles" ; tiles: string ; tileSize: 256 | 512 ; minzoom: number ; maxzoom: number ; opacity: number ; resampling: "linear" | "nearest" ; attribution: string } | { kind: "glStyle" ; style: string } | { kind: "archive" ; archive: string } What an overlay layer draws.

AppOverlayKind

Ƭ AppOverlayKind: AppOverlaySource["kind"]

AppMapArchiveStatus

Ƭ AppMapArchiveStatus: Object A declared map archive as the layer editor shows it (mapArchiveStatus). recorder says who records its versions: the program’s own tile (program: an administrator tiles the newest published version, tileMapArchive, and the archive follows the next publications), or, for an archive that declares no tile, an external producer holding a producer grant for its dataset (producer). drawn is the version recorded now (a producer names its own version label) and newest the dataset’s newest published version. follows, whether the caller may tile (administers) and the latest run with the reason it was left unrecorded describe the program’s tiling: false, false and null for a producer-recorded archive.

Type declaration

Name	Type
`key`	`string`
`label`	`string`
`dataset`	`string`
`column`	`string`
`recorder`	`"program"` \| `"producer"`
`drawn`	{ `version`: `string` } \| `null`
`newest`	`string` \| `null`
`follows`	`boolean`
`administers`	`boolean`
`run`	{ `version`: `string` ; `recording`: `"pending"` \| `"recorded"` \| `"unrecorded"` ; `note`: `string` \| `null` } \| `null`

AppOverlayLayer

Ƭ AppOverlayLayer: Object

Type declaration

Name	Type
`source`	`AppOverlaySource`
`style?`	`AppLayerStyle`

AppSavedOverlay

Ƭ AppSavedOverlay: Object One saved overlay layer as its reader may open it.

Type declaration

Name	Type	Description
`id`	`string`	-
`name`	`string`	-
`revision`	`number`	-
`sharing`	`AppMapSharing`	Shared like a saved map (AppMapSharing).
`is_owner`	`boolean`	-
`can_edit`	`boolean`	The caller may save it: its owner, or an editor `sharing.edit` admits.
`overlay`	`AppOverlayLayer`	-

AppOverlayListing

Ƭ AppOverlayListing: Object One listed overlay layer, without its source.

Type declaration

Name	Type
`id`	`string`
`name`	`string`
`kind`	`AppOverlayKind`
`revision`	`number`
`sharing`	`AppMapSharing`
`is_owner`	`boolean`
`can_edit`	`boolean`

AppMapSettings

Ƭ AppMapSettings: Object The deployment’s map settings.

Type declaration

Name	Type	Description
`defaults`	{ `viewport`: { `center`: [`number`, `number`] ; `zoom`: `number` } \| `null` ; `units`: `AppMapUnits` ; `timeZone`: `"utc"` \| `"local"` ; `basemap`: `string` \| `null` ; `timeWindowMs`: `number` }	-
`defaults.viewport`	{ `center`: [`number`, `number`] ; `zoom`: `number` } \| `null`	-
`defaults.units`	`AppMapUnits`	-
`defaults.timeZone`	`"utc"` \| `"local"`	-
`defaults.basemap`	`string` \| `null`	A basemap option id; null draws the first option.
`defaults.timeWindowMs`	`number`	-
`pollingMs`	`number`	URL overlays refresh at this interval.
`limits`	{ `objectsPerLayer`: `number` ; `searchAroundSources`: `number` ; `trackPoints`: `number` }	-
`limits.objectsPerLayer`	`number`	Objects one layer draws individually before it counts per cell.
`limits.searchAroundSources`	`number`	-
`limits.trackPoints`	`number`	-
`customBasemaps`	`AppBasemapOption`[]	Keyless basemaps the administrators add, besides the program’s.
`watermarks`	{ `group`: `string` ; `text`: `string` }[]	Watermark rules, at most APP_MAP_WATERMARKS: a member sees the text of the first rule naming a group they are in (a group the program’s `maps.groups` declares), else the program’s own watermark for them, else none. Distinct groups; text 1 to APP_MAP_WATERMARK characters.

AppBasemapChoice

Ƭ AppBasemapChoice: Object One basemap a member may choose, as the browser draws it: a proxied option’s tiles are bijection-tile://<id>/{z}/{x}/{y} (the mapTile action); available is false while its key variable is unset.

Type declaration

Name	Type
`id`	`string`
`label`	`string`
`basemap`	`AppBasemap`
`proxied`	`boolean`
`available`	`boolean`

AppMapSettingsView

Ƭ AppMapSettingsView: AppMapSettings & { basemaps: AppBasemapChoice[] ; watermark: string | null ; groups: { id: string ; label: string }[] ; canAdminister: boolean ; revision: number } The map settings a member reads. watermarks holds the rules for an administrator only (empty for everyone else).

AppCanonicalGeoJson

Ƭ AppCanonicalGeoJson: { ok: true ; data: string ; features: number ; bytes: number ; heights: number } | { ok: false ; reason: string } An uploaded GeoJSON overlay in canonical form, or why it is refused.

AppCanonicalGlStyle

Ƭ AppCanonicalGlStyle: { ok: true ; style: string ; sources: number ; layers: number } | { ok: false ; reason: string } A GL style fragment in canonical form, or why it is refused.

AppMapExportKind

Ƭ AppMapExportKind: "png" | "geojson" What a map export was: a PNG capture or a GeoJSON download.

AppExportFormat

Ƭ AppExportFormat: typeof APP_EXPORT_FORMATS[number] One of APP_EXPORT_FORMATS.

AppFeatureExportFormat

Ƭ AppFeatureExportFormat: typeof APP_FEATURE_EXPORT_FORMATS[number] One of APP_FEATURE_EXPORT_FORMATS.

AppExportArgs

Ƭ AppExportArgs: { kind: AppMapExportKind ; map: string | null ; name: string ; layers: { id: string ; title: string ; collection: string | null }[] } | { kind: "objects" ; collection: string ; format: AppExportFormat ; count: number ; scope: "view" | "selection" } | { kind: "feature" ; feature: string ; name: string ; format: AppFeatureExportFormat ; count: number } Arguments of recordExport. A map export: its kind, the map exported (a saved map’s id, or null for an unsaved one), its name and the layers drawn (at most MAP_LAYERS; collection null for an overlay or annotations). An object export: the collection read, the file’s format, how many objects it holds and whether they were a view’s (view) or a selection (selection). A feature export: a file a feature’s page writes from its own reads (an analysis memo, a result’s rows), named by the feature’s installation id in the exporter’s catalog, the file’s name, its format and how many records it holds.

AppExport

Ƭ AppExport: AppExportArgs & { id: string ; at: string ; owner: string ; person: string | null ; watermark: string | null } One entry of the export audit, as an administrator lists it.

AppMapColor

Ƭ AppMapColor: typeof APP_MAP_COLORS[number]

AppStyleValue

Ƭ AppStyleValue: { kind: "title" } | { kind: "property" ; property: string } | { kind: "series" ; property: string ; field: string } | { kind: "function" ; name: string } | { kind: "linkedCount" ; relation: string } | { kind: "linkedEvents" ; relation: string ; state: "active" | "all" } Where a styled value comes from.

AppStyleEntryValue

Ƭ AppStyleEntryValue: string | number | boolean | null A categorical entry’s value: an exact scalar.

AppColorStyle

Ƭ AppColorStyle: { kind: "fixed" ; color: AppMapColor } | { kind: "categorical" ; value: AppStyleValue ; entries: { value: AppStyleEntryValue ; color: AppMapColor }[] ; other: AppMapColor } | { kind: "gradient" ; value: AppStyleValue ; ramp: "sequential" | "heat" | "diverging" ; domain: [number, number] | null ; steps: number } | { kind: "hex" ; value: AppStyleValue }

AppSizeStyle

Ƭ AppSizeStyle: { kind: "fixed" ; size: number } | { kind: "scaled" ; value: AppStyleValue ; domain: [number, number] | null ; range: [number, number] } Marker, line or icon size in CSS pixels.

AppChoroplethAggregate

Ƭ AppChoroplethAggregate: { kind: "count" } | { kind: "sum" | "mean" | "min" | "max" ; measure: string } | { kind: "ratio" ; numerator: string ; denominator: string } | { kind: "expression" ; expr: AppAggregateExpr } What a choropleth region shows: exact counts and int64 sums from the ordinary summary; a ratio divides two exact sums on the client, and an expression combines a region’s exact sums, its count and decimal constants in exact rational arithmetic on the client.

AppAggregateExpr

Ƭ AppAggregateExpr: { sum: string } | { count: true } | { const: string } | { op: "+" | "-" | "*" | "/" ; args: [AppAggregateExpr, AppAggregateExpr] } An arithmetic expression over one region’s exact figures: the exact sum of a declared measure, the region’s object count, or a decimal constant, combined by + - * /. Evaluated in exact rationals; a division by zero anywhere gives the region no value (drawn as no data), never a rounded or infinite one. Bounded by APP_AGGREGATE_EXPR.

AppLayerStyle

Ƭ AppLayerStyle: Object

Type declaration

Name	Type	Description
`display`	`"points"` \| `"icons"` \| `"lines"` \| `"areas"` \| `"heatmap"` \| `"clusters"` \| `"grid"` \| `"hexagons"` \| `"choropleth"` \| `"track"` \| `"breadcrumbs"` \| `"imagery"`	-
`color`	`AppColorStyle`	-
`opacity?`	`number`	0..1, the layer’s opacity.
`size?`	`AppSizeStyle`	-
`icon?`	{ `kind`: `"fixed"` ; `name`: `string` } \| { `kind`: `"mapped"` ; `value`: `AppStyleValue` ; `entries`: { `value`: `AppStyleEntryValue` ; `name`: `string` }[] ; `other`: `string` } \| { `kind`: `"media"` ; `property`: `string` }	Icons from the workspace icon set (lucide names), fixed or by value, or each object’s own image: a property declaring `media`, whose file the workspace reads through `mediaFiles` and the media route (at most APP_MEDIA_LAYER_IMAGES distinct images per layer).
`rotation?`	{ `kind`: `"heading"` } \| { `kind`: `"track"` } \| { `kind`: `"property"` ; `property`: `string` }	Icon rotation: the latest heading of the layer’s series, the direction of travel along its track (a track or breadcrumbs display only: arrows along the line, each breadcrumb towards the next), or a numeric property in degrees clockwise from north.
`marker?`	`"circle"` \| `"pin"` \| `"none"`	-
`label?`	{ `value`: `AppStyleValue` ; `show`: `"always"` \| `"hover"` \| `"never"` }	-
`label.value`	`AppStyleValue`	-
`label.show`	`"always"` \| `"hover"` \| `"never"`	-
`time?`	{ `activeOpacity`: `number` ; `inactiveOpacity`: `number` ; `bufferMs`: `number` ; `fadeMs`: `number` ; `hideUntilOccurred`: `boolean` }	Time-based opacity against the map’s time: a feature is active from its time until `bufferMs` after it, then fades to `inactiveOpacity` over `fadeMs`; `hideUntilOccurred` hides features after the map’s time.
`time.activeOpacity`	`number`	-
`time.inactiveOpacity`	`number`	-
`time.bufferMs`	`number`	-
`time.fadeMs`	`number`	-
`time.hideUntilOccurred`	`boolean`	-
`cells?`	{ `system`: `"h3"` \| `"geohash"` ; `resolution`: `number` \| `"auto"` }	Grid (geohash) or hexagon (H3) cells; absent is `auto`.
`cells.system`	`"h3"` \| `"geohash"`	-
`cells.resolution`	`number` \| `"auto"`	-
`choropleth?`	{ `property`: `string` ; `aggregate`: `AppChoroplethAggregate` }	The boundary property grouped by, and what each region shows.
`choropleth.property`	`string`	-
`choropleth.aggregate`	`AppChoroplethAggregate`	-
`imagery?`	{ `property`: `string` ; `resampling`: `"linear"` \| `"nearest"` }	Display “imagery”: the property declaring `media: { kind: "imagery" }` whose archive each object draws as tiled imagery (read by range through the media route, at most APP_MEDIA_LAYER_IMAGERY per layer) over its footprint, the layer’s source field, resampled between pixels as a raster overlay is: smooth (`linear`) or sharp (`nearest`).
`imagery.property`	`string`	-
`imagery.resampling`	`"linear"` \| `"nearest"`	-
`radius?`	{ `property`: `string` }	A points or icons display: a circle around each object’s point whose radius is an admitted numeric property, in metres (Foundry’s circle via radius), drawn as a geodesic polygon in the layer’s colour. A value that is missing, not above 0 or above APP_STYLE_RADIUS_METRES draws no circle, and the layer says how many.
`radius.property`	`string`	-

AppLinkedPagesArgs

Ƭ AppLinkedPagesArgs: Object The first page of relation of each of ids (objects of collection, at most APP_STYLE_LINKED_OBJECTS and at most what one point read of the type names), in order of the relation’s index: numItems (1 to APP_LINKED_PAGE) linked objects each, and of each linked object its id and fields (at most APP_LINKED_FIELDS admitted properties of the target). Read by linkedPages, the same authorized reads as connections, sharing one read budget.

Type declaration

Name	Type
`collection`	`string`
`relation`	`string`
`ids`	`string`[]
`numItems`	`number`
`order?`	`"asc"` \| `"desc"`
`orderBy?`	`string`
`fields?`	`string`[]

AppLinkedPages

Ƭ AppLinkedPages: Object Each named object’s linked page: count linked objects read, complete when that is all of them (else count is a lower bound), unavailable identities, and rows (each linked object’s _id and asked fields). Denied access refuses the complete read; unread names those the shared read budget ended before (no page).

Type declaration

Name	Type
`pages`	`Record`<`string`, { `count`: `number` ; `complete`: `boolean` ; `rows`: `Record`<`string`, `unknown`>[] ; `unavailable`: `string`[] }>
`unread`	`string`[]

AppMediaFile

Ƭ AppMediaFile: Object One object’s media file as the media route serves it: the route path (relative to the deployment API origin), the stored file, its size in bytes and its contentType. Protected files use the native authenticated fixed-file route, ordinary files the application’s media route. Never a bearer URL.

Type declaration

Name	Type
`path`	`string`
`file`	`string`
`size`	`number`
`contentType`	`string`

AppStyleFunctions

Ƭ AppStyleFunctions: readonly { name: string ; collection: string }[] Registered map values the check admits: AppCatalog.maps.values.

AppMapUnits

Ƭ AppMapUnits: "metric" | "imperial" | "nautical"

AppMapParameter

Ƭ AppMapParameter: { id: string ; label: string ; kind: "objects" ; collection: string } | { id: string ; label: string ; kind: "string" | "number" | "datetime" ; default?: string | null } A template parameter: objects of one collection, or one primitive value whose default is exact text (a number as a decimal, a datetime as int64 epoch milliseconds).

AppMapParameterValue

Ƭ AppMapParameterValue: string | string[] | null A parameter’s value: object ids for objects, exact text otherwise, null for none.

AppMapObjectScope

Ƭ AppMapObjectScope: Pick<AppView, "filters" | "filterMode" | "groups" | "related" | "linked" | "within" | "search"> & { ids?: string[] | { parameter: string } ; parameterFilters?: { field: string ; operator?: AppFilter["operator"] ; parameter: string }[] } The objects one layer draws.

AppMapAnnotation

Ƭ AppMapAnnotation: Object One item of an annotation layer.

Type declaration

Name	Type	Description
`id`	`string`	-
`kind`	`"text"` \| `"line"` \| `"polygon"` \| `"rectangle"` \| `"circle"` \| `"measure"`	-
`geometry`	`AppGeometry`	A Point for text.
`text?`	`string`	At most MAP_ANNOTATION_TEXT characters.
`measure?`	`"length"` \| `"area"` \| `"perimeter"`	-

AppMapLayerSource

Ƭ AppMapLayerSource: { kind: "objects" ; collection: string ; field: string ; view: AppMapObjectScope ; time?: string ; loading?: "auto" | "objects" | "tiles" ; track?: AppMapTrackPresentation } | { kind: "links" ; from: string ; hops: AppSearchHop[] ; field: string ; merged: boolean } | { kind: "links" ; from: string ; function: string ; field: string ; merged: boolean } | { kind: "overlay" ; layer: string } | { kind: "annotations" ; items: AppMapAnnotation[] } What one layer draws.

AppMapLayer

Ƭ AppMapLayer: Object One layer of a map.

Type declaration

Name	Type	Description
`id`	`string`	1 to 40 of `[A-Za-z0-9_-]`, unique in the map.
`title`	`string`	1 to 80 characters.
`visible`	`boolean`	-
`locked`	`boolean`	Selection tools skip a locked layer.
`source`	`AppMapLayerSource`	-
`style?`	`AppLayerStyle`	Absent: the defaults for the layer’s geometry types.
`minzoom?`	`number`	0 to 24: shown from this zoom (inclusive).
`maxzoom?`	`number`	0 to 24: hidden from this zoom (exclusive).

AppMapDocument

Ƭ AppMapDocument: Object A map as it is saved.

Type declaration

Name	Type	Description
`layers`	`AppMapLayer`[]	Drawing order, bottom first.
`viewport`	{ `center`: [`number`, `number`] ; `zoom`: `number` ; `bearing`: `number` ; `pitch`: `number` } \| `null`	-
`time`	{ `at`: `string` \| `null` ; `window`: { `from`: `string` ; `to`: `string` } \| `null` ; `following`: `boolean` } \| `null`	-
`settings`	{ `units`: `AppMapUnits` ; `timeZone`: `"utc"` \| `"local"` ; `seriesBuckets?`: `number` }	-
`settings.units`	`AppMapUnits`	-
`settings.timeZone`	`"utc"` \| `"local"`	-
`settings.seriesBuckets?`	`number`	Buckets each series chart draws, 1 to MAP_SERIES_BUCKETS; absent: MAP_SERIES_BUCKETS.
`basemap`	`string` \| `null`	A basemap option id; null = the deployment default.
`parameters`	`AppMapParameter`[]	Non-empty: a template.
`series?`	{ `collection`: `string` ; `id`: `string` ; `property`: `string` ; `measure`: `string` }[]	Measures of objects’ series pinned to the series panel, charted on the map’s time (at most MAP_SERIES_PINS, each once). Absent: none.

AppMapSharing

Ƭ AppMapSharing: Object Who opens and who edits a saved map or overlay layer. view: "workspace" lists and opens it for every member while its owner passes authorize. edit names who besides the owner saves it, at its current revision: nobody ("owner"), every member who may open it ("workspace"), or the named people (distinct ids of the application’s people collection, at most MAP_EDITORS, only when the application declares people). Editing needs viewing, so a private record’s edit is "owner". Only the owner deletes a record or changes its sharing.

Type declaration

Name	Type
`view`	`"private"` \| `"workspace"`
`edit`	`"owner"` \| `"workspace"` \| { `people`: `string`[] }

AppSavedMap

Ƭ AppSavedMap: Object One saved map as its reader may open it.

Type declaration

Name	Type	Description
`id`	`string`	-
`name`	`string`	-
`revision`	`number`	-
`sharing`	`AppMapSharing`	-
`is_owner`	`boolean`	-
`can_edit`	`boolean`	The caller may save it: its owner, or an editor `sharing.edit` admits.
`document`	`AppMapDocument`	-
`declared?`	`true`	A map template the program declares (`maps.templates`): never saved over; a member saves a copy.

AppSeriesLatestArgs

Ƭ AppSeriesLatestArgs: Object

Type declaration

Name	Type	Description
`collection`	`string`	-
`property`	`string`	-
`ids`	`string`[]	At most SERIES_LATEST_IDS distinct object ids.
`measures?`	`string`[]	Measures of the property (built-in or declared, distinct, at most `SERIES_LATEST_MEASURES`, 4) whose latest values to read.
`at?`	`string`	Decimal epoch ms. Absent: the latest report. Present: each object’s position at this instant under the property’s declared interpolation (or the layer’s track presentation, `track`), and each measure’s value of the last report at or before it.
`track?`	`AppMapTrackPresentation`	Absent: the declared interpolation and gap. Applies only with `at` (the latest report is the same under every presentation).

AppSeriesLatest

Ƭ AppSeriesLatest: Object The latest point of each readable object’s series, by object id (null: no report yet, no series id, or no such object); restricted counts the objects the caller may not read, which are left out. values holds each asked measure of the latest report by object id (null: no latest report, or the report did not carry it): a float64, or an int64 as decimal text. With at, each point is the object at that instant: position is the estimate under the presentation (null when unknown there, e.g. across a gap longer than the policy), time the source time of the report in force at or before the instant (or of the report after it that a next or nearest estimate used), and speed, heading, height and values those of the report in force (null when none). null: no report places the object at the instant.

Type declaration

Name	Type	Description
`estimates?`	`Record`<`string`, `AppPositionEstimate`>	Derivation and accuracy, when supplied by the series reader.
`latest`	`Record`<`string`, `AppSeriesPoint` \| `null`>	-
`restricted`	`number`	-
`values`	`Record`<`string`, `Record`<`string`, `number` \| `string` \| `null`>>	-
`at`	`string` \| `null`	Echo of `at`, or null.
`expired`	`string`[]	Objects whose instant is before their type’s hot horizon: `latest` is null for them and the map says the position is in the archive.
`held`	`string`[]	Objects whose position at `at` holds their newest report past its time (they have not reported since): a map draws them as last known. Empty without `at`.

AppMapTrackPresentation

Ƭ AppMapTrackPresentation: Object A map layer’s choice of how tracks read (Foundry: Linear or Last known, Max time gap). max_gap_ms (a positive integer of milliseconds) is at most the property’s declared gap (AppSeriesField.max_gap_ms: the map document check and every series read refuse a wider one); absent, the declared gap applies.

Type declaration

Name	Type
`interpolation`	`"linear"` \| `"previous"`
`max_gap_ms?`	`number`

AppMapField

Ƭ AppMapField: Object One mappable field of a collection.

Type declaration

Name	Type	Description
`name`	`string`	-
`label`	`string`	-
`kind`	`"geometry"` \| `"series"`	`geometry`: a declared geometry (value, derived point or cell); `series`: a declared series property drawn at its latest position.
`types`	`AppGeometryType`[]	-

AppObjectTileArgs

Ƭ AppObjectTileArgs: Object One z/x/y web-mercator tile of an objects layer (objectTile): the layer’s scope view (browse’s arguments without paging) with the tile’s box as a spatial clause, the geometry field field drawn, and columns (at most MAP_TILE_COLUMNS admitted properties the layer’s style reads) copied into each feature.

Type declaration

Name	Type
`view`	`Omit`<`AppBrowseArgs`, `"paginationOpts"`>
`field`	`string`
`z`	`number`
`x`	`number`
`y`	`number`
`columns`	`string`[]

AppObjectTile

Ƭ AppObjectTile: Object One object tile: its objects’ geometry, simplified to the tile’s pixel tolerance (a point exactly), with the asked columns, when the tile holds at most MAP_TILE_OBJECTS objects in at most MAP_TILE_BYTES; otherwise complete is false, features is empty, over says which bound ended it (budget: the read budget ended a page) and count is the objects the tile’s read reached, a lower bound. Objects the caller may not read are never read.

Type declaration

Name	Type
`features`	{ `id`: `string` ; `geometry`: `AppGeometry` ; `values`: `Record`<`string`, `unknown`> }[]
`complete`	`boolean`
`count`	`number`
`over`	`null` \| `"objects"` \| `"bytes"` \| `"budget"`

AppMention

Ƭ AppMention: Object One mention in a text: the person’s id, the label its token carries, and where the token starts and ends in the text.

Type declaration

Name	Type
`id`	`string`
`label`	`string`
`start`	`number`
`end`	`number`

AppMarkdownHrefPart

Ƭ AppMarkdownHrefPart: { text: string } | { property: string } One part of a link address: literal text, or a template placeholder whose value is percent-encoded into the address (appMarkdownHref).

AppMarkdownInline

Ƭ AppMarkdownInline: { kind: "text" ; text: string } | { kind: "strong" | "emphasis" ; children: AppMarkdownInline[] } | { kind: "code" ; text: string } | { kind: "link" ; href: AppMarkdownHrefPart[] ; children: AppMarkdownInline[] } | { kind: "property" ; property: string } | { kind: "mention" ; id: string ; label: string }

AppMarkdownBlock

Ƭ AppMarkdownBlock: { kind: "paragraph" ; children: AppMarkdownInline[] } | { kind: "heading" ; level: 1 | 2 | 3 ; children: AppMarkdownInline[] } | { kind: "list" ; ordered: boolean ; items: AppMarkdownInline[][] } | { kind: "code" ; text: string }

AppMarkdown

Ƭ AppMarkdown: Object

Type declaration

Name	Type	Description
`blocks`	`AppMarkdownBlock`[]	-
`properties`	`string`[]	The distinct placeholder properties, in order of first use, in text and in link addresses. Empty unless parsed as a template.
`refusedLinks`	`string`[]	The addresses of links refused because their literal start is not `https://`, `http://` or `mailto:`, as written.

AppNumberPresentation

AppNumberShape

Ƭ AppNumberShape: "bigint" | "number"

AppObserveScope

AppObserveMeasure

Ƭ AppObserveMeasure: { kind: "count" } | { kind: "sum" ; property: string } What an observation measures: the objects’ count, or the exact int64 sum of a declared measure (a collection’s measures).

AppObserveRequest

Ƭ AppObserveRequest: Object One observation request.

mode: "validate" checks the scope, measure and properties against the catalog and reads no row: the answer is valid with the scope as it will be read.
mode: "observe" reads: with measure null, the scope’s objects (at most limit, 1 to APP_OBSERVE_OBJECTS_MAX) with their digests and the values of properties (at most APP_OBSERVE_PROPERTIES_MAX admitted properties); with a measure, one exact figure.

asOf is the UTC day (YYYY-MM-DD) the scope is read on; it resolves the scope’s relative date ranges and is required whether or not it holds one.

Type declaration

Name	Type
`mode`	`"validate"` \| `"observe"`
`scope`	`AppObserveScope`
`asOf`	`string`
`measure`	`AppObserveMeasure` \| `null`
`properties`	`string`[]
`limit`	`number`

AppObservedObject

Ƭ AppObservedObject: Object One object of an observation. values holds each requested property the object has; a missing property is absent.

Type declaration

Name	Type
`id`	`string`
`digest`	`string`
`values`	`Record`<`string`, `Value`>

AppObservation

Ƭ AppObservation: { kind: "valid" ; scope: AppObserveScope } | { kind: "objects" ; objects: AppObservedObject[] ; nextBoundary: number | null } | { kind: "measure" ; value: bigint ; exact: "maintained" | "bounded" ; nextBoundary: number | null } | { kind: "incomplete" ; reason: "bound" | "related" | "withheld" ; limit: number ; aggregate: { by: string[] ; sum: string[] } | null } What an observation answers.

valid: the request checks (validate mode only).
objects: every object of the scope, in the scope’s read order.
measure: the exact count or int64 sum; maintained when a declared aggregate answered it (exact at any size), bounded when one bounded read counted every matching object.
incomplete: no answer is exact. bound: the read stopped at a bound before it had every matching object; related: a relationship clause could not be resolved within its bounds; withheld: the collection gives this read no bound in visited rows. limit is the bound, not a count of matching objects: the request’s limit when more objects matched it; otherwise the bounded read’s, which for an access-checked collection counts rows visited whether or not they match (0 once the read budget is spent), and which row conditions, relationship clauses and region candidates narrow only after it. The answer does not say which, so bound proves no lower bound on how many objects the scope holds. aggregate names the declaration that would answer the measure exactly at any size, or null.

nextBoundary is the next UTC midnight after asOf when the scope holds a relative date range — the first instant its membership can change without a write — and null otherwise.

AppPlace

Ƭ AppPlace: Object Map location protocol values; installation belongs to workspace.

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.

AppPlaceOffering

Ƭ AppPlaceOffering: Object

Type declaration

Name	Type	Description
`registered`	`boolean`	The program registers location search.
`offered`	`boolean`	A provider is configured and asked.
`provider`	`string` \| `null`	The provider, as its reader names it; null when none.
`reverse`	`boolean`	Reverse geocoding (`placeReverse`) is registered.
`configure`	`string` \| `null`	The declared operation that sets the provider, or null.

AppInterpolationMode

Ƭ AppInterpolationMode: typeof APP_INTERPOLATION_MODES[number]

AppSeriesPoint

Ƭ AppSeriesPoint: Object One report of a series, as the workspace reads it.

Type declaration

Name	Type	Description
`time`	`string`	Source time: int64 epoch milliseconds as a decimal string.
`position`	[`number`, `number`] \| `null`	WGS84 `[longitude, latitude]`; null when the report had no usable fix.
`altitudeMetres`	`number` \| `null`	Height above the WGS84 ellipsoid in metres, when reported.
`speedMps`	`number` \| `null`	-
`headingDegrees`	`number` \| `null`	Degrees clockwise from true north, 0 <= heading < 360.

AppSeriesTrack

Ƭ AppSeriesTrack: Object A bounded window of one series.

Type declaration

Name	Type	Description
`series`	`string`	-
`from`	`string`	-
`to`	`string` \| `null`	null: an open window that grows with every new report (a live tail).
`points`	`AppSeriesPoint`[]	Known fixes in time order (equal-time corrections collapsed).
`breaks`	`number`[]	Ascending indexes `i` where the line from `points[i - 1]` to `points[i]` is not drawn: an unknown report or a gap longer than `max_gap_ms` lies between them. Nothing is drawn across a break.
`max_gap_ms`	`string`	The gap policy the breaks were computed with (decimal milliseconds).
`downsampled`	`boolean`	True when the server simplified the window to fit `max_points`; the retained reports stay authoritative.
`is_complete`	`boolean`	False when the window held more reports than one read serves (a closed window then ends early, an open one starts late: the newest are kept), or when `expiredThrough` is set.
`expiredThrough`	`string` \| `null`	Decimal epoch ms: the newest source time the series type’s hot store expired reports through, when the window reaches back to it. Reports of the window at or before it may be missing here (they are in the series’ archive). null: the window is whole.
`withheld`	`boolean`	True when the series type’s markings withhold the series from the caller: no point is answered, `is_complete` is false and `expiredThrough` null.

AppSeriesObservation

Ƭ AppSeriesObservation: Omit<AppSeriesPoint, "position"> & { position: Position | null ; quality: "fix" | "missing" | "invalid" ; is_late: boolean ; fields: Record<string, Value> } One retained report as the observation log shows it.

AppSeriesLog

Ƭ AppSeriesLog: Object The newest reports of a window, newest first.

Type declaration

Name	Type	Description
`observations`	`AppSeriesObservation`[]	-
`is_complete`	`boolean`	False when the window holds more reports than were asked for, or when `expiredThrough` is set.
`expiredThrough`	`string` \| `null`	As expiredThrough.
`withheld`	`boolean`	As withheld: no report is answered.

AppSeriesArea

Ƭ AppSeriesArea: { type: "Polygon" ; coordinates: number[][][] } | { type: "MultiPolygon" ; coordinates: number[][][][] } The area a track search draws: a closed WGS84 Polygon or MultiPolygon.

AppSeriesEntries

Ƭ AppSeriesEntries: Object One page of every retained report of a window, oldest first by (time, sequence).

Type declaration

Name	Type	Description
`observations`	`AppSeriesObservation`[]	-
`continueCursor`	`string` \| `null`	The exact position after this page’s last report, or null when the window holds no further report.
`isDone`	`boolean`	-
`expiredThrough`	`string` \| `null`	As expiredThrough: set when `from, to)` reaches the expiry horizon (reports before it are in the archive, not here).
`withheld`	`boolean`	As [withheld: no report is answered.

AppSeriesSearchMatch

Ƭ AppSeriesSearchMatch: Object One series whose track meets the area, as its reader names it.

Type declaration

Name	Type	Description
`id`	`string`	The object whose declared id property holds `series`.
`series`	`string`	-
`firstAt`	`string`	Decimal epoch ms: the source time of the first segment (or lone fix) of the window that meets the area.

AppSeriesSearch

Ƭ AppSeriesSearch: Object A reader’s track search.

Type declaration

Name	Type	Description
`matches`	`AppSeriesSearchMatch`[]	-
`is_complete`	`boolean`	False when a bound cut the search, or when `expiredThrough` is set.
`expiredThrough`	`string` \| `null`	As expiredThrough, for the series type.
`withheld`	`boolean`	As withheld: nothing was searched.

AppSeriesSearchArgs

Ƭ AppSeriesSearchArgs: Object Arguments of the application’s seriesSearch query.

Type declaration

Name	Type	Description
`collection`	`string`	-
`property`	`string`	The declared series property of the collection.
`area`	`AppSeriesArea`	-
`from`	`string`	Window (decimal epoch ms), ordered and at most SERIES_SEARCH_WINDOW_MS long.
`to`	`string`	-
`limit?`	`number`	1..SERIES_SEARCH_LIMIT; default and cap also bounded by the collection’s point read.

AppSeriesSearchResult

Ƭ AppSeriesSearchResult: Object The objects whose track met the area, in the reader’s order; objects the caller may not read are counted in restricted, not named.

Type declaration

Name	Type	Description
`matches`	{ `id`: `string` ; `firstAt`: `string` }[]	-
`restricted`	`number`	-
`is_complete`	`boolean`	-
`expiredThrough`	`string` \| `null`	-
`withheld`	`boolean`	True when the series type’s markings withhold its tracks from the caller: nothing was searched, no match is named.

AppSeriesMeasureArgs

Ƭ AppSeriesMeasureArgs: Object Arguments of the application’s seriesMeasure query.

Type declaration

Name	Type	Description
`collection`	`string`	-
`id`	`string`	-
`property`	`string`	The declared series property of the collection.
`measure`	`string`	A built-in measure or one the property declares.
`from`	`string`	Window start (decimal epoch ms).
`to?`	`string`	Window end (decimal epoch ms), at most SERIES_MAX_WINDOW_MS after `from`. Omitted: an open window that grows with every report.
`max_points?`	`number`	1..SERIES_MAX_POINTS; default SERIES_DEFAULT_POINTS.

AppSeriesMeasure

Ƭ AppSeriesMeasure: Object One measure of a series over a window.

Type declaration

Name	Type	Description
`measure`	`string`	-
`points`	{ `time`: `string` ; `value`: `number` \| `string` \| `null` }[]	Source time (decimal epoch ms) and the value: a finite float64, an int64 as decimal text, or null (a report without it: a gap), in time order with equal-time corrections collapsed.
`breaks`	`number`[]	As breaks: ascending indexes `i` where the line from `points[i - 1]` to `points[i]` is not drawn (either value is null, or the reports are further apart than the series’ gap policy).
`max_gap_ms`	`string`	The gap policy the breaks were computed with (decimal milliseconds): a value is never held or interpolated across a longer silence.
`downsampled`	`boolean`	True when the window held more reports than `max_points`: each time bucket keeps its minimum, its maximum and its first gap, and the window its newest report, so extremes, gaps and the latest value survive. Every point is then a report, but not every report between two points is answered: a value between them is read from a narrower window.
`is_complete`	`boolean`	As is_complete.
`expiredThrough`	`string` \| `null`	As expiredThrough.
`withheld`	`boolean`	As withheld: no point is answered.

AppSeriesWindowUnit

Ƭ AppSeriesWindowUnit: typeof SERIES_WINDOW_UNITS[number]

AppSeriesSignalInterpolation

Ƭ AppSeriesSignalInterpolation: typeof SERIES_SIGNAL_INTERPOLATIONS[number]

AppSeriesValue

Ƭ AppSeriesValue: number | bigint | string One measured value: a float64 as a number, an int64 as a bigint, a decimal as its exact text.

AppSeriesAnswer

Ƭ AppSeriesAnswer: { kind: "empty" } | { kind: "overflow" } | { kind: "int64" ; value: bigint } | { kind: "float64" ; value: number } | { kind: "decimal" ; value: string ; scale: number } | { kind: "rational" ; coefficient: string ; denominator: string ; scale: number } An exact answer of an analysis, never an integer or decimal through floating point: empty (no sample carries the measure), overflow (the exact answer does not fit), or a value; rational is exactly coefficient / (denominator × 10^scale) (a mean of int64 or decimal samples).

AppSeriesCoverage

Ƭ AppSeriesCoverage: Object What an analysis evaluated: the range [from, to) and where its retained population begins. Before visible_from the range is absent from the answer (retention), not empty. Instants are exact decimal epoch milliseconds (appSeriesMillis).

Type declaration

Name	Type	Description
`from`	`string`	-
`to`	`string`	-
`visible_from`	`string`	-
`is_complete`	`boolean`	-
`basis_id?`	`string`	Analyses only: the identity of the selected population.
`publication?`	{ `required_ms`: `string` ; `available_ms`: `string` ; `examined_ms`: `string` ; `is_complete`: `boolean` ; `is_final`: `boolean` }	-
`publication.required_ms`	`string`	-
`publication.available_ms`	`string`	-
`publication.examined_ms`	`string`	-
`publication.is_complete`	`boolean`	-
`publication.is_final`	`boolean`	-

AppSeriesAnalysisArgs

Ƭ AppSeriesAnalysisArgs: Object Arguments every series analysis takes.

Type declaration

Name	Type	Description
`collection`	`string`	-
`id`	`string`	-
`property`	`string`	The declared series property of the collection.
`measure`	`string`	A built-in measure or one the property declares.
`from`	`string`	The half-open range `[from, to)` (decimal epoch ms), nonempty and at most SERIES_ANALYSIS_WINDOW_MS long.
`to`	`string`	-

AppSeriesWindowsArgs

Ƭ AppSeriesWindowsArgs: AppSeriesAnalysisArgs & { window: AppSeriesWindowUnit } Arguments of the application’s seriesWindows query.

AppSeriesChartArgs

Ƭ AppSeriesChartArgs: AppSeriesAnalysisArgs & { max_points: number } Arguments of the application’s seriesChart query.

AppSeriesSignalArgs

Ƭ AppSeriesSignalArgs: AppSeriesAnalysisArgs & { interpolation: AppSeriesSignalInterpolation ; max_gap_ms?: number } Arguments of the application’s seriesSignal query.

AppSeriesExpressionArgs

Ƭ AppSeriesExpressionArgs: Object Arguments of the application’s seriesExpression query: property names an expression property, or a series property with an ad hoc expression (a seriesExpr tree’s node).

Type declaration

Name	Type	Description
`collection`	`string`	-
`id`	`string`	-
`property`	`string`	-
`from`	`string`	Decimal epoch milliseconds, `[from, to)`.
`to`	`string`	-
`expression?`	`SeriesExpressionNode`	-
`output`	`"samples"` \| `"windows"` \| `"chart"` \| `"summary"` \| `"episodes"`	-
`window?`	`AppSeriesWindowUnit`	-
`max_points?`	`number`	-
`min_duration_ms?`	`number`	-
`max_gap_ms?`	`number`	-

AppSeriesFleetArgs

Ƭ AppSeriesFleetArgs: Object Rank a native temporal property or a component-backed track expression. Native properties use their admitted formula and accept no expression or alignment override.

Type declaration

Name	Type
`collection`	`string`
`ids`	`string`[]
`property`	`string`
`from`	`string`
`to`	`string`
`expression?`	`SeriesExpressionNode`
`aggregate`	keyof `AppSeriesExpressionAggregate`
`order?`	`"asc"` \| `"desc"`
`max_gap_ms?`	`number`

AppSeriesFleet

Ƭ AppSeriesFleet: Object Objects ranked by one aggregate of a series expression.

Type declaration

Name	Type
`aggregate`	keyof `AppSeriesExpressionAggregate`
`order`	`"asc"` \| `"desc"`
`rows`	({ `id`: `string` ; `state`: `"none"` \| `"withheld"` } \| { `id`: `string` ; `state`: `"answered"` ; `count`: `string` ; `answer`: `AppSeriesAnswer` })[]

AppSeriesAnalysis

Ƭ AppSeriesAnalysis<Answer>: { state: "answered" } & Answer | { state: "none" } | { state: "withheld" } An analysis, or why there is none: none, the object names no series; withheld, the series type’s markings withhold its series from the caller (nothing else is answered).

Type parameters

Name
`Answer`

AppSeriesPropertyRead

Ƭ AppSeriesPropertyRead: SeriesRead<AppSeriesChart | AppSeriesWindows | AppSeriesSignal | SeriesExpressionSummary | AppSeriesSignalWindows | AppSeriesExpression> | SeriesPage<SeriesEvent<Record<string, Value | undefined>>> | SeriesPage<SeriesSample<Record<string, Value | undefined>>> An authorized native property read, with its work and coverage outcome. Events and samples retain their exact native timestamps.

AppSeriesPropertyAnalysis

Ƭ AppSeriesPropertyAnalysis: null | { state: "pending" } | { state: "failed" ; error: SeriesAnalysisFailure } | { state: "ready" ; kind: "signal_windows" ; answer: AppSeriesSignalWindows } | { state: "ready" ; kind: "summary" ; answer: SeriesExpressionSummary } | { state: "ready" ; kind: "chart" ; answer: AppSeriesChart } | { state: "ready" ; kind: "windows" ; answer: AppSeriesWindows } | { state: "ready" ; kind: "signal" ; answer: AppSeriesSignal } | { state: "ready" ; kind: "signal_summary" ; answer: AppSeriesSignal } | { state: "ready" ; kind: "episodes" | "samples" ; answer: AppSeriesExpression } A retained property analysis formatted using its original settings.

AppSeriesWindows

Ƭ AppSeriesWindows: Object One measure summarized per calendar window, exactly.

Type declaration

Name	Type	Description
`measure`	`string`	-
`window`	`AppSeriesWindowUnit`	-
`coverage`	`AppSeriesCoverage`	-
`windows`	{ `from`: `string` ; `to`: `string` ; `is_excluded`: `boolean` ; `accepted_event_count`: `bigint` ; `resolved_sample_count`: `bigint` ; `count`: `bigint` ; `missing_count`: `bigint` ; `null_count`: `bigint` ; `min`: `AppSeriesValue` \| `null` ; `max`: `AppSeriesValue` \| `null` ; `sum`: `AppSeriesAnswer` ; `mean`: `AppSeriesAnswer` }[]	In time order; the first and last are clipped to the range.

AppSeriesChart

Ƭ AppSeriesChart: Object One measure reduced to at most max_points samples for drawing.

Type declaration

Name	Type	Description
`interpretation`	{ `kind`: `"samples"` } \| { `kind`: `"signal"` ; `interpolation`: `AppSeriesSignalInterpolation` ; `max_gap_ms`: `string` }	-
`max_points`	`number`	-
`measure`	`string`	-
`coverage`	`AppSeriesCoverage`	-
`is_reduced`	`boolean`	True when some samples are not points: each bucket kept its first, last, lowest and highest.
`buckets`	{ `from`: `string` ; `to`: `string` ; `resolved_sample_count`: `bigint` ; `missing_count`: `bigint` ; `null_count`: `bigint` ; `is_excluded`: `boolean` ; `is_gap_present`: `boolean` ; `support_from?`: `string` \| `null` ; `support_to?`: `string` \| `null` ; `points`: { `time`: `string` ; `value`: `AppSeriesValue` \| `AppSeriesAnswer` }[] }[]	Buckets of one width aligned to UTC multiples of it, clipped to the range, in order.

AppSeriesSignal

Ƭ AppSeriesSignal: Object One measure weighted by time between samples. The integral is in the measure’s unit × seconds.

Type declaration

Name	Type	Description
`measure`	`string`	-
`coverage`	`AppSeriesCoverage`	-
`interpolation`	`AppSeriesSignalInterpolation` \| `"composed"`	-
`max_gap_ms`	`string` \| `null`	The gap policy applied, in exact decimal milliseconds.
`covered_ms`	`string`	Exact decimal ms of the range between two samples within the gap (a linear interval also needs its later sample’s value), and the rest.
`uncovered_ms`	`string`	-
`integral`	`AppSeriesAnswer`	-
`covered_mean`	`AppSeriesAnswer`	The integral over the covered duration alone.
`interval_mean`	`AppSeriesAnswer` \| { `kind`: `"incomplete"` }	The mean over the whole range: `incomplete` while any of it is uncovered.

AppSeriesSignalWindows

Ƭ AppSeriesSignalWindows: Object Time-weighted answers over UTC windows, with the same signal policy.

Type declaration

Name	Type
`measure`	`string`
`coverage`	`AppSeriesCoverage`
`window`	`AppSeriesWindowUnit`
`windows`	{ `from`: `string` ; `to`: `string` ; `summary`: `AppSeriesSignal` }[]

AppSeriesArgs

Ƭ AppSeriesArgs: Object Arguments of the application’s series query.

Type declaration

Name	Type	Description
`collection`	`string`	-
`id`	`string`	-
`property`	`string`	The declared series property of the collection.
`from?`	`string`	Window start (decimal epoch ms). Omitted: only the latest point.
`to?`	`string`	Window end (decimal epoch ms). Omitted: an open, live-growing window.
`max_points?`	`number`	1..SERIES_MAX_POINTS; default SERIES_DEFAULT_POINTS.
`log?`	`number`	1..SERIES_MAX_LOG: also read the window’s newest `log` reports (requires `from`). Omitted: no log.
`entries?`	{ `cursor`: `string` \| `null` ; `limit`: `number` }	A paged read of every report in `[from, to)`, oldest first by (time, sequence); requires `from` and `to` (at most SERIES_ENTRIES_WINDOW_MS apart) and `limit` 1.. SERIES_ENTRIES_PAGE. `cursor` is null for the first page, then the previous page’s `continueCursor` for the same window. A read with `entries` answers only `latest` and `entries` (no track, and no `log` may be asked).
`entries.cursor`	`string` \| `null`	-
`entries.limit`	`number`	-
`presentation?`	`AppMapTrackPresentation`	Applied to `track`: its breaks follow the presentation’s gap (at most the declared one). See AppMapTrackPresentation.

AppSeriesResult

Ƭ AppSeriesResult: Object

Type declaration

Name	Type	Description
`latest`	`AppSeriesPoint` \| `null`	The series’ latest report by (time, sequence); null when the object names no series or the series holds no current report.
`track`	`AppSeriesTrack` \| `null`	null when `from` was omitted or the object names no series.
`log`	`AppSeriesLog` \| `null`	null when `log` was omitted or the object names no series.
`entries`	`AppSeriesEntries` \| `null`	null when `entries` was omitted or the object names no series.
`withheld`	`boolean`	True when the series type’s markings withhold the object’s series from the caller: `latest`, `track`, `log` and `entries` are then null.

AppPositionEstimate

Ƭ AppPositionEstimate: { state: "known" ; method: "observed" | Exclude<AppInterpolationMode, "none"> ; position: Position ; before: string | null ; after: string | null ; fraction: number | null } | { state: "unknown" ; reason: string } The derivation of a map position. Observation accuracy is retained only for an observed value. Identities identify the reports used by the reader.

AppSeriesReader

Ƭ AppSeriesReader: Object How the program reads one declared series property. Its functions run inside the application’s series query with the caller’s context, after the object itself was read through the ordinary authorized get; they must read only through ordinary Bijection reads so the query stays reactive. @bijectionhq/datasets/geotemporal builds one (appSeriesReader).

Type declaration

Name	Type	Description
`maxGapMs`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>) => `Promise`<`number` \| `null`>	The series type’s declared gap in milliseconds (a positive whole number), read in the calling query (a gap policy may be stored state); null while none is declared. No line is drawn and no position held across a longer silence, and a presentation’s `max_gap_ms` is at most this. The catalog serves it (`series_gaps`) so a map offers and saves only gaps within it.
`readable?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>) => `Promise`<`boolean`>	May the caller read this series type (its markings)? Asked before any other method; false answers every series of the type as withheld. Absent: the type carries no markings.
`latest`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`) => `Promise`<`AppSeriesPoint` \| `null`>	-
`track`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `window`: { `from`: `bigint` ; `to`: `bigint` \| `null` ; `max_points`: `number` ; `max_gap_ms`: `number` \| `null` }) => `Promise`<`AppSeriesTrack`>	`max_gap_ms`: a presentation’s gap for the breaks (the reader refuses one wider than its declared gap); null: the declared gap.
`at`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `query`: { `at`: `bigint` ; `measures`: readonly `string`[] ; `interpolation`: `AppInterpolationMode` ; `max_gap_ms`: `number` \| `null` }) => `Promise`<{ `point`: `AppSeriesPoint` \| `null` ; `estimate?`: `AppPositionEstimate` ; `values`: `Record`<`string`, `number` \| `string` \| `null`> ; `held`: `boolean` ; `expired`: `boolean` ; `withheld`: `boolean` }>	The series at one instant: the position under `interpolation` and `max_gap_ms` (null: the declared gap; the reader refuses a wider one), and each of `measures` (served ones) of the report in force at or before `at`. `point` as `AppSeriesLatest` describes it with `at`; null when no report places the series there. `held`: the instant is after the series’ newest report and `point` holds that report’s position (at most the gap after it). `expired`: the instant is before the retained history (expiry removed the report in force), so `point` is null.
`entries`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `window`: { `from`: `bigint` ; `to`: `bigint` ; `cursor`: `string` \| `null` ; `limit`: `number` }) => `Promise`<`AppSeriesEntries`>	One page of every retained report in `[from, to)`, oldest first by (time, sequence), at most `limit`, with the fields the reader discloses (as its observation log). `cursor`: null, or a `continueCursor` it returned for the same window.
`observations`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `window`: { `from`: `bigint` ; `to`: `bigint` \| `null` ; `limit`: `number` }) => `Promise`<`AppSeriesLog`>	The newest `limit` reports in the window, newest first; `to: null` reads to the newest report.
`search?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `query`: { `area`: `AppSeriesArea` ; `from`: `bigint` ; `to`: `bigint` ; `limit`: `number` }) => `Promise`<`AppSeriesSearch`>	The series whose recorded track within `[from, to]` meets `area`, at most `limit`, each with the object that names it. Absent: the property offers no track search.
`measures`	readonly `string`[]	The measures `measure` serves: at least the built-ins (`speedMps`, `headingDegrees`, `altitudeMetres`) and every measure the property’s presentation declares, which the application checks when it is defined.
`measure`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `window`: { `from`: `bigint` ; `to`: `bigint` \| `null` ; `measure`: `string` ; `max_points`: `number` }) => `Promise`<`AppSeriesMeasure`>	One measure over `[from, to]` (`to: null` reads to the newest report), at most `max_points` points; one of `measures`.
`windows?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `query`: { `from`: `bigint` ; `to`: `bigint` ; `measure`: `string` ; `window`: `AppSeriesWindowUnit` }) => `Promise`<`SeriesWindows`>	The native analyses of one of `measures` over `[from, to)` in signed microseconds, as `ctx.series.query(table)` windows, chart and signal plans answer them for the series (the application converts to the wire’s milliseconds, and types the native read bounds’ refusals). Each is optional: absent, the property offers no such analysis.
`chart?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `query`: { `from`: `bigint` ; `to`: `bigint` ; `measure`: `string` ; `max_points`: `number` }) => `Promise`<`SeriesChart`>	-
`signal?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `query`: { `from`: `bigint` ; `to`: `bigint` ; `measure`: `string` ; `interpolation`: `AppSeriesSignalInterpolation` ; `max_gap`: `bigint` }) => `Promise`<`SeriesSignalSummary`>	`max_gap` in microseconds.
`expression?`	(`ctx`: `GenericQueryCtx`<`GenericDataModel`>, `series`: `string`, `query`: { `from`: `bigint` ; `to`: `bigint` ; `node`: `SeriesExpressionNode` ; `output`: `AppSeriesExpressionOutput` ; `max_gap`: `bigint` \| `null` }) => `Promise`<`SeriesExpressionAnswer`>	One series expression over `[from, to)` in signed microseconds, as a selection’s `expression` plan answers it; `max_gap` in microseconds, null when the series declares none. Absent: the property offers no expressions.

AppSeriesExpressionOutput

Ƭ AppSeriesExpressionOutput: { kind: "samples" } | { kind: "windows" ; window: AppSeriesWindowUnit } | { kind: "chart" ; max_points: number } | { kind: "summary" } | { kind: "episodes" ; min_duration_ms: number } What an expression analysis answers.

AppSeriesExpressionValue

Ƭ AppSeriesExpressionValue: { kind: "absent" } | { kind: "null" } | { kind: "number" ; value: AppSeriesValue } | { kind: "truth" ; value: boolean | null } | { kind: "string" ; value: string } | { kind: "boolean" ; value: boolean } One expression value at an output instant.

AppSeriesExpressionAggregate

Ƭ AppSeriesExpressionAggregate: Object Every aggregate of one population of expression values.

Type declaration

Name	Type
`count`	`string`
`nulls`	`string`
`missing`	`string`
`min`	`AppSeriesAnswer`
`max`	`AppSeriesAnswer`
`first`	`AppSeriesAnswer`
`last`	`AppSeriesAnswer`
`sum`	`AppSeriesAnswer`
`mean`	`AppSeriesAnswer`
`stddev`	`AppSeriesAnswer`
`difference`	`AppSeriesAnswer`
`relative_difference`	`AppSeriesAnswer`

AppSeriesExpression

Ƭ AppSeriesExpression: { coverage: AppSeriesCoverage ; context_from: string ; identity: { definition_digest: string ; question_id: string ; result_digest: string ; kernel: string } } & { output: "samples" ; points: { time: string ; value: AppSeriesExpressionValue }[] ; next: string | null } | { output: "windows" ; windows: { from: string ; to: string ; is_excluded: boolean ; aggregate: AppSeriesExpressionAggregate }[] } | { output: "chart" ; is_reduced: boolean ; buckets: { from: string ; to: string ; is_excluded: boolean ; is_gap_present: boolean ; points: { time: string ; value: AppSeriesValue }[] }[] } | { output: "summary" ; aggregate: AppSeriesExpressionAggregate } | { output: "episodes" ; episodes: { start: string ; end: string | null ; start_cause: "crossing" | "observed" ; end_cause: "false" | "unknown" | "gap" | null ; is_clipped: boolean }[] } An expression’s answer in exact decimal epoch milliseconds. context_from is where operator history began. Outputs before coverage.visible_from read history retention shortened and are not answered.

AppSeriesPropertyOperation

AppSeriesProperty

Ƭ AppSeriesProperty: Object Native property meaning excludes physical routing and key expressions.

Type declaration

Name	Type
`measure`	`string`
`unit`	`string` \| `null`
`value`	{ `kind`: `"float64"` \| `"int64"` \| `"condition"` \| `"string"` \| `"boolean"` } \| { `kind`: `"decimal"` ; `scale`: `number` }
`reads`	`AppSeriesPropertyOperation`[]
`preparations`	(`"summary"` \| `"windows"` \| `"chart"` \| `"signal"` \| `"signal_summary"` \| `"signal_chart"` \| `"signal_windows"` \| `"samples"` \| `"episodes"`)[]
`signal?`	{ `interpolation`: `"previous"` \| `"linear"` ; `max_gap`: `string` } \| { `interpolation`: `"interval"` }
`interpolations`	(`"previous"` \| `"linear"` \| `"interval"`)[]

AppSeriesField

Ƭ AppSeriesField: Object One declared series property of a collection.

Type declaration

Name	Type	Description
`value_kind?`	`"condition"` \| `"string"` \| `"boolean"`	-
`signal?`	`AppSeriesProperty`[`"signal"`]	-
`kind`	`"native"` \| `"track"`	-
`name`	`string`	The derived property’s name.
`label`	`string`	-
`id`	`string`	The stored identity property of a track, or the reference path of a native property.
`interpolation`	`AppInterpolationMode`	The declared interpolation (“linear” when none is declared).
`measures`	{ `name`: `string` ; `label`: `string` ; `unit`: `string` \| `null` }[]	The built-in measures, then the declared ones in declaration order.
`style`	`AppLayerStyle` \| `null`	The series type’s default map style (`series.style`): a map layer drawing this property without a style of its own uses it.
`max_gap_ms`	`number` \| `null`	The series type’s declared gap in milliseconds (its reader’s `max_gap_ms`, served in the catalog as `series_gaps`): a presentation’s gap is at most this. Null while the series declares none, or where no catalog states it (the deployment’s own declaration check).

SeriesDeclarations

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

Type declaration

Name	Type
`validator_json`	`string`
`series_properties?`	`Record`<`string`, `AppSeriesProperty`>
`series_gaps?`	`Record`<`string`, `number` \| `null`>
`properties?`	`Record`<`string`, { `label?`: `string` ; `format?`: `string` ; `series?`: { `id`: `string` ; `interpolation?`: `string` ; `measures?`: `Record`<`string`, { `label`: `string` ; `unit?`: `string` }> ; `style?`: `AppLayerStyle` } ; `expression?`: { `of`: `string` ; `value`: `SeriesExpressionNode` ; `unit?`: `string` ; `max_gap_ms?`: `number` } }>

AppExpressionField

Ƭ AppExpressionField: Object One expression over a component-backed track property.

Type declaration

Name	Type	Description
`name`	`string`	The derived property’s name.
`label`	`string`	-
`of`	`string`	The series property whose samples it computes over.
`node`	`SeriesExpressionNode`	-
`kind`	`"number"` \| `"condition"`	A condition answers episodes; a number answers values and charts.
`unit`	`string` \| `null`	-
`max_gap_ms`	`number` \| `null`	The declared gap bound, at most the series property’s; null: its.

AppExpressionLeaf

Ƭ AppExpressionLeaf: Object One leaf of an expression tree: the measure it reads and the series property (null: the expression’s own) or raw series it names.

Type declaration

Name	Type
`measure`	`string`
`property`	`string` \| `null`
`series`	`string` \| `null`

AppShareRole

Ƭ AppShareRole: "viewer" | "editor" What a named grant allows: open (viewer) or also save (editor).

AppSavedRole

Ƭ AppSavedRole: "owner" | AppShareRole The caller’s role on a saved view or graph: the stronger of what they hold, owner first.

AppSavedAccess

Ƭ AppSavedAccess: Object How the caller holds a saved view or graph.

role: owner, or the stronger of a named grant and general access (general access is viewer).
is_shared: every member may open it (general access).
has_people: it is shared with named people; reported to its owner only, false for everyone else.
shared_by: the person who granted it to the caller by name, an id of AppCatalog.people; null exactly when the caller holds it as its owner or through general access alone (only one of the application’s people names people, so every named grant has a sharer).

Type declaration

Name	Type
`role`	`AppSavedRole`
`is_shared`	`boolean`
`has_people`	`boolean`
`shared_by`	`string` \| `null`

AppShareGrant

Ƭ AppShareGrant: Object One named grant: a person of AppCatalog.people and their role.

Type declaration

Name	Type
`person`	`string`
`role`	`AppShareRole`

AppShares

Ƭ AppShares: Object Who a saved view or graph is shared with, as its owner reads it (shares).

Type declaration

Name	Type
`id`	`string`
`kind`	`"view"` \| `"graph"` \| `"lineage"`
`name`	`string`
`revision`	`number`
`is_shared`	`boolean`
`people`	`AppShareGrant`[]

AppTimeUnit

Ƭ AppTimeUnit: typeof APP_TIME_UNITS[number]

QuestionOutputTypes

Ƭ QuestionOutputTypes: Record<string, { kind: "table" | "one" ; row: unknown }> Not exported: an exported type refers to it.

AnswerPage

Ƭ AnswerPage<Row>: Object Not exported: an exported type refers to it.

Type parameters

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

Type declaration

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

FileFieldProjection

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

Type declaration

Name	Type
`path`	(`string` \| `null`)[]
`source_path`	(`string` \| `null`)[]

Variables

APP_PAGE_ITEMS

• Const APP_PAGE_ITEMS: 50 Objects one browse page lists at most (page_items).

APP_RELATED_CANDIDATES

• Const APP_RELATED_CANDIDATES: 128 Linked objects one relationship clause with an indexed equality reads (related_candidates).

APP_RELATED_BYTES

• Const APP_RELATED_BYTES: number Bytes of those linked objects (related_bytes).

APP_REGION_TOTAL_ROWS

• Const APP_REGION_TOTAL_ROWS: 4096 Objects one region summary that no maintained total answers counts one by one, read page after page through the region’s index (region_totals): any grouping (dynamic cells, a pivot, several measures) is exact up to it and refused past it.

APP_REGION_TOTAL_BYTES

• Const APP_REGION_TOTAL_BYTES: number Bytes of those objects (region_total_bytes): half of the engine’s read per transaction.

APP_SPATIAL_ORDER_ROWS

• Const APP_SPATIAL_ORDER_ROWS: 500 Rows one ordered merge of a region’s ranges visits for one page, matching or not, before it must advance (spatial_order_rows).

APP_SPATIAL_ORDER_BYTES

• Const APP_SPATIAL_ORDER_BYTES: number Bytes of those rows (spatial_order_bytes).

APP_SPATIAL_ORDER_TIES

• Const APP_SPATIAL_ORDER_TIES: 64 Rows sharing one sort value and creation time an ordered merge’s continuation reads past (spatial_order_ties).

APP_SEARCH_AROUND_ROWS

• Const APP_SEARCH_AROUND_ROWS: 4096 Targets one Search Around hop with a region reads through the target collection’s spatial index, whatever the links per source (search_around_rows): the region join’s own bound.

APP_MENTIONS_MAX

• Const APP_MENTIONS_MAX: 16 Distinct people one comment may mention.

APP_CURSOR_CHARS

• Const APP_CURSOR_CHARS: 4096 Characters an encoded application cursor holds at most; a longer one is refused as malformed.

discoveryApi

• Const discoveryApi: Object

Type declaration

Name	Type
`discover`	`FunctionReference`<`"query"`, `"public"`, `DiscoverArgs`, `DiscoveryPage`, `undefined` \| `string`>
`describe`	`FunctionReference`<`"query"`, `"public"`, { `ref`: `function: $\{string}\` \\| \`collection:$ {string}` \| `operation: $\{string}\` \\| \`relation:$ {string}` \| `interface:${string}` }, `DiscoveryDescription`, `undefined` \| `string`>
`argumentChoices`	`FunctionReference`<`"query"`, `"public"`, `ArgumentChoicesArgs`, `ArgumentChoicesPage`, `undefined` \| `string`>

APP_GEOMETRY_TYPES

• Const APP_GEOMETRY_TYPES: readonly ["Point", "MultiPoint", "LineString", "MultiLineString", "Polygon", "MultiPolygon"] GeoJSON geometry types in canonical order.

APP_GEOMETRY_PROFILES

• Const APP_GEOMETRY_PROFILES: readonly ["wgs84-2d-linear-sphere-v1", "wgs84-3d-hae-linear-sphere-v1"] The geometry profiles: WGS84 [longitude, latitude], and the same with a height in metres above the WGS84 ellipsoid.

APP_GEOMETRY_SIZES

• Const APP_GEOMETRY_SIZES: readonly ["standard", "large"] The size tiers of the 2D profile; the 3D profile has the standard tier only.

APP_REGION_VERTICES

• Const APP_REGION_VERTICES: 8192 Positions one drawn region’s polygon or line may carry: the geometry profile’s large-tier ring bound, so a province-sized boundary is a region. The native spatial execution account refuses a query whose predicates cost more. An object region carries the stored value’s own large-tier bound.

APP_REGION_VERTEX_REFUSAL

• Const APP_REGION_VERTEX_REFUSAL: string Why a drawn region past APP_REGION_VERTICES is refused: the engine’s array bound, which no tier of the geometry profile passes. A query refuses it as a typed bound_exceeded (bound: "region_vertices", limit APP_REGION_VERTICES).

APP_REGION_MAX_METRES

• Const APP_REGION_MAX_METRES: number The largest radius a distance region takes: half the circumference of the geometry profile’s sphere.

APP_SPATIAL_MODES

• Const APP_SPATIAL_MODES: readonly ["intersects", "disjoint", "within", "contains"] How a geometry property relates to a region (Foundry’s geoshape filter modes), boundary inclusive:

intersects: the value and the region share a point. For a point property this is “the point lies in the region”.
disjoint: they share none; the complement of intersects among objects with a value. An object without a value matches neither.
within: every point of the value lies in the region.
contains: every point of the region lies in the value (a polygon).

A point property takes intersects and disjoint; a shape property takes all four. A point whose accuracy envelope straddles the region’s boundary may intersect it, so it is in intersects and never in disjoint.

APP_SPATIAL_CLAUSES

• Const APP_SPATIAL_CLAUSES: 4 Spatial clauses one view holds in all: its within and those of its filter groups.

APP_NEAREST_LIMIT

• Const APP_NEAREST_LIMIT: 100 The most objects one nearest clause ranks.

APP_CELL_SYSTEMS

• Const APP_CELL_SYSTEMS: Object The grid systems a cell summary groups by, with their resolutions: geohash precision 1–9, H3 resolution 0–15.

Type declaration

Name	Type
`geohash`	{ `min`: `1` = 1; `max`: `9` = 9 }
`geohash.min`	`1`
`geohash.max`	`9`
`h3`	{ `min`: `0` = 0; `max`: `15` = 15 }
`h3.min`	`0`
`h3.max`	`15`

APP_SPATIAL_OBJECTS

• Const APP_SPATIAL_OBJECTS: 500 The most objects one spatial clause resolves: the rows one exploration reads (a summary’s bounded read too). A region or disjoint scope holding more is refused whole (exceeded: "region"), never cut or paged; under per-row access checks the read-subject budget bounds it lower. Counting more located objects per cell, at any size, is a stored cell dimension’s maintained total.

APP_SPATIAL_PARTITIONS

• Const APP_SPATIAL_PARTITIONS: 16 Admitted partitions one ordered region read merges: a collection whose spatial index partitions it for the caller lists a region in the view’s order by merging each admitted partition’s ordered range, one lookahead row per range. More are refused (bound_exceeded, spatial_partitions).

APP_CANONICAL_PRECISION

• Const APP_CANONICAL_PRECISION: 9 The finest precision of a canonical geohash cell.

GRAPH_BADGES

• Const GRAPH_BADGES: 2 Badges one node type shows.

GRAPH_NOTES

• Const GRAPH_NOTES: 12 Notes one graph holds.

GRAPH_NOTE_CHARS

• Const GRAPH_NOTE_CHARS: 280 Characters one note holds.

GRAPH_GROUPS

• Const GRAPH_GROUPS: 10 Groups one graph holds.

GRAPH_GROUP_NAME

• Const GRAPH_GROUP_NAME: 40 Characters one group name holds.

SAVED_GRAPH_STYLES

• Const SAVED_GRAPH_STYLES: 8 Named graph styles one member keeps.

SAVED_GRAPH_STYLE_TYPES

• Const SAVED_GRAPH_STYLE_TYPES: 16 Object types one saved style covers.

SAVED_GRAPH_STYLES_CHARS

• Const SAVED_GRAPH_STYLES_CHARS: 6144 The most characters all of a member’s saved styles encode to together: their share of the one preferences record.

WORKSPACE_API_VERSION

• Const WORKSPACE_API_VERSION: "operator-workspace-40" The one protocol name of the operator workspace API: the catalog reports it as api_version, and a workspace refuses a catalog that reports another.

READ_SUBJECT_LIMIT

• Const READ_SUBJECT_LIMIT: 1024 The engine admits at most this many read-access subjects in one query (MAX_READ_ACCESS_SUBJECTS in crates/database/src/reads.rs) and refuses the WHOLE query with “Business read scope is too large” beyond it.

RESERVED_READ_SUBJECTS

• Const RESERVED_READ_SUBJECTS: 32 Subjects every application query leaves to authentication, authorize, the catalog and point reads it makes outside its bounded reads.

APP_READ_SUBJECT_BUDGET

• Const APP_READ_SUBJECT_BUDGET: number Subjects one application query may spend on its bounded reads.

appIdentifierPattern

• Const appIdentifierPattern: RegExp Kebab-case identifier shared by lucide icon names and exposed feature kinds.

MAX_INLINE_EDITS

• Const MAX_INLINE_EDITS: 16 At most this many properties of one collection declare an inline edit.

APP_SEARCH_WINDOW

• Const APP_SEARCH_WINDOW: 1024 The engine ranks at most this many matches per search (MAX_CANDIDATE_REVISIONS in crates/search/src/constants.rs); a word search continues through them and ends at them with end: "window".

APP_RELATION_CLAUSES

• Const APP_RELATION_CLAUSES: 4 Relationship clauses one view holds.

APP_LINK_PROBE_LINKS

• Const APP_LINK_PROBE_LINKS: 25 Links of one object a relationship clause without an indexed equality tests.

APP_LINK_JOIN_CANDIDATES

• Const APP_LINK_JOIN_CANDIDATES: 4096 Linked objects one relationship clause’s region join reads, and the objects of the view’s collection it may drive the scope with.

SEARCH_AROUND_HOPS

• Const SEARCH_AROUND_HOPS: 3 Declared relations one Search Around follows.

SEARCH_AROUND_FILTERS

• Const SEARCH_AROUND_FILTERS: 8 Filters one hop’s where holds, all of which must match.

SEARCH_AROUND_FANOUT

• Const SEARCH_AROUND_FANOUT: 25 Matching targets one hop reads from each object the previous hop reached.

SEARCH_AROUND_OBJECTS

• Const SEARCH_AROUND_OBJECTS: 50 Distinct objects one hop keeps; the rest are “more available”.

APP_SEARCH_LIMIT

• Const APP_SEARCH_LIMIT: 50 Titles one type’s search group lists at most (its limit; 5 when omitted).

APP_FAVORITES

• Const APP_FAVORITES: 64 Items one member may keep as favorites.

GRAPH_SAVE_LIMIT

• Const GRAPH_SAVE_LIMIT: 16384 The most characters one encoded saved graph may reach.

GRAPH_NODES

• Const GRAPH_NODES: 50 Nodes one graph holds; the object tab uses GRAPH_EMBEDDED_NODES.

GRAPH_EDGES

• Const GRAPH_EDGES: 49 Association records plus named relation memberships one graph holds.

GRAPH_EMBEDDED_NODES

• Const GRAPH_EMBEDDED_NODES: 25 Node limit of the graph embedded in an object view.

GRAPH_EMBEDDED_EDGES

• Const GRAPH_EMBEDDED_EDGES: 24 Edge limit of the graph embedded in an object view.

GRAPH_TYPES

• Const GRAPH_TYPES: 32 Distinct collections one graph names.

SAVED_GRAPHS

• Const SAVED_GRAPHS: 20 Saved graphs one member owns.

GRAPH_POSITION_LIMIT

• Const GRAPH_POSITION_LIMIT: 100000 Largest absolute node coordinate.

APP_SUMMARY_TOP

• Const APP_SUMMARY_TOP: 256 The most groups a ranked summary lists (AppSummaryArgs.top): one maintained answer page, the engine’s MAX_AGGREGATE_GROUPS.

APP_NOTICE_MESSAGE_MAX

• Const APP_NOTICE_MESSAGE_MAX: 2000 A notice’s message is cut to this many characters.

APP_NOTICE_REFERENCE_MAX

• Const APP_NOTICE_REFERENCE_MAX: 128 The longest event reference a delivered notice carries (the occurrence reference its category resolves), and the longest recipient: a person id.

APP_NOTICE_ROUTE_MAX

• Const APP_NOTICE_ROUTE_MAX: 2048 The longest value of one AppNoticeRoute parameter.

ACCESS_REQUEST_TEXT_MAX

• Const ACCESS_REQUEST_TEXT_MAX: 1000 Characters in a reason or a decision comment.

MAX_STATUS_SOURCES

• Const MAX_STATUS_SOURCES: 32 Installed sources one status call discloses. The engine admits at most 128 read-access subjects per query (MAX_READ_ACCESS_SUBJECTS in crates/database/src/reads.rs); a source status presents one per source, plus the whole relation, the object row and the authorize callback’s own.

LINEAGE_REPORT_STATES

• Const LINEAGE_REPORT_STATES: 64 States the host keeps from one report.

LINEAGE_REPORT_EDGES

• Const LINEAGE_REPORT_EDGES: 64 Edges the host keeps from one report.

SAVED_LINEAGES

• Const SAVED_LINEAGES: 20 Saved lineages one member may keep.

LINEAGE_FOCUS_CHARS

• Const LINEAGE_FOCUS_CHARS: 200 The longest focus id a saved lineage keeps.

LINEAGE_SEARCH_CHARS

• Const LINEAGE_SEARCH_CHARS: 80 The longest search a saved lineage keeps.

MAP_RENDER_OBJECTS

• Const MAP_RENDER_OBJECTS: 1000 Objects one mapLayerObjects answer carries; more is refused.

MAP_RENDER_BYTES

• Const MAP_RENDER_BYTES: number Encoded bytes of the objects one answer carries; more is refused.

MAP_RENDER_READ_BYTES

• Const MAP_RENDER_READ_BYTES: number Bytes of rows one answer’s region reads may visit in all, matching or not (8 MiB, half of one transaction’s reads): a filtered layer reads page after page until its objects are found or these are spent, then is refused.

APP_OVERLAY_BYTES

• Const APP_OVERLAY_BYTES: number UTF-8 bytes of one uploaded GeoJSON overlay’s canonical text.

APP_OVERLAY_FEATURES

• Const APP_OVERLAY_FEATURES: 10000 Features one uploaded GeoJSON overlay (or one GeoJSON URL response) holds.

APP_OVERLAY_STYLE_BYTES

• Const APP_OVERLAY_STYLE_BYTES: number UTF-8 bytes of one GL style fragment’s canonical text.

APP_OVERLAY_PROPERTIES

• Const APP_OVERLAY_PROPERTIES: 32 Properties one overlay feature carries.

APP_OVERLAY_TEXT

• Const APP_OVERLAY_TEXT: 256 Characters of one overlay feature’s string property.

APP_OVERLAY_GL

• Const APP_OVERLAY_GL: Object Sources and layers one GL style fragment declares.

Type declaration

Name	Type
`sources`	`8`
`layers`	`32`

SAVED_OVERLAYS

• Const SAVED_OVERLAYS: 50 Overlay layers one member owns.

MAX_SHARED_OVERLAYS_PER_OWNER

• Const MAX_SHARED_OVERLAYS_PER_OWNER: 20 Overlay layers one member shares.

MAX_LISTED_SHARED_OVERLAYS

• Const MAX_LISTED_SHARED_OVERLAYS: 50 Shared overlay layers one listing reads, newest first.

APP_BASEMAP_OPTIONS

• Const APP_BASEMAP_OPTIONS: 8 Basemap options the program declares, and custom basemaps the deployment settings hold.

APP_MAP_TEXT

• Const APP_MAP_TEXT: Object Characters of a URL, and of an attribution.

Type declaration

Name	Type
`url`	`512`
`attribution`	`200`
`label`	`80`

APP_MAP_WATERMARK

• Const APP_MAP_WATERMARK: 80 Characters of a watermark.

APP_MAP_WATERMARKS

• Const APP_MAP_WATERMARKS: 16 Watermark rules the deployment settings hold, and groups a program declares for them.

APP_MAP_GROUPS

• Const APP_MAP_GROUPS: 32

MAP_EXPORTS_PAGE

• Const MAP_EXPORTS_PAGE: 50 Export audit entries one exports page lists.

APP_MAP_TILE_BYTES

• Const APP_MAP_TILE_BYTES: number Bytes of one tile the mapTile action returns.

APP_MAP_TILE_TYPES

• Const APP_MAP_TILE_TYPES: readonly string[] Content types a tile the mapTile action returns may have: raster images only (a proxied basemap is a raster one).

APP_MAP_SETTINGS

• Const APP_MAP_SETTINGS: Object The deployment settings’ bounds and defaults.

Type declaration

Name	Type
`pollingMs`	{ `min`: `5000` = 5_000; `max`: `3600000` = 3_600_000; `default`: `60000` = 60_000 }
`pollingMs.min`	`5000`
`pollingMs.max`	`3600000`
`pollingMs.default`	`60000`
`objectsPerLayer`	{ `min`: `100` = 100; `max`: `5000` = 5_000; `default`: `1000` = 1_000 }
`objectsPerLayer.min`	`100`
`objectsPerLayer.max`	`5000`
`objectsPerLayer.default`	`1000`
`searchAroundSources`	{ `min`: `1` = 1; `max`: `25` = 25; `default`: `25` = 25 }
`searchAroundSources.min`	`1`
`searchAroundSources.max`	`25`
`searchAroundSources.default`	`25`
`trackPoints`	{ `min`: `100` = 100; `max`: `2000` = SERIES_MAX_POINTS; `default`: `500` = SERIES_DEFAULT_POINTS }
`trackPoints.min`	`100`
`trackPoints.max`	`2000`
`trackPoints.default`	`500`
`timeWindowMs`	{ `min`: `60000` = 60_000; `max`: `604800000` = SERIES_MAX_WINDOW_MS; `default`: `3600000` = 3_600_000 }
`timeWindowMs.min`	`60000`
`timeWindowMs.max`	`604800000`
`timeWindowMs.default`	`3600000`

APP_OVERLAY_KINDS

• Const APP_OVERLAY_KINDS: readonly AppOverlayKind[]

APP_MAP_ARCHIVE_KEY

• Const APP_MAP_ARCHIVE_KEY: RegExp A map archive’s key (defineApplication({ maps: { archives } })), and a declared map template’s id.

APP_MAP_DECLARED

• Const APP_MAP_DECLARED: 32 The most map archives, and map templates, a program declares.

APP_MAP_TEMPLATE_PREFIX

• Const APP_MAP_TEMPLATE_PREFIX: "program:" A declared map template opens as the saved map program:<id> (savedMap), read-only: a member saves a copy.

APP_ARCHIVE_SOURCE_LAYER

• Const APP_ARCHIVE_SOURCE_LAYER: "features" The tile layer an archive overlay draws from a vector (MVT) archive: a producer names its layer so (tippecanoe -l features).

APP_MAP_GROUP

• Const APP_MAP_GROUP: RegExp A group id a program declares for watermark rules.

APP_EXPORT_FORMATS

• Const APP_EXPORT_FORMATS: readonly ["csv", "xlsx", "json", "geojson"] The files an object export writes.

APP_EXPORT_ROWS

• Const APP_EXPORT_ROWS: 10000 Objects one export writes at most: the workspace’s export reads stop there, and recordExport refuses a record of more (bound_exceeded, export_rows).

APP_FEATURE_EXPORT_FORMATS

• Const APP_FEATURE_EXPORT_FORMATS: readonly ["html", "print", "csv"] The files a feature’s own export writes: a document (html), the same document sent to the browser’s print dialog (print, which may save it as PDF), or rows (csv).

APP_MAP_COLORS

• Const APP_MAP_COLORS: readonly ["ink", "area", "track", "muted", "cat1", "cat2", "cat3", "cat4", "cat5", "cat6", "cat7", "cat8"] Map theme colour tokens: --map-<token> (cat1 is --map-cat-1).

APP_AGGREGATE_EXPR

• Const APP_AGGREGATE_EXPR: Object The bounds of an AppAggregateExpr: nesting depth (a leaf is depth 1), node count, and a constant’s decimal digits.

Type declaration

Name	Type
`depth`	`8`
`nodes`	`32`
`constDigits`	`30`

APP_STYLE_ENTRIES

• Const APP_STYLE_ENTRIES: 24 Categorical and mapped-icon entries per style.

APP_STYLE_STEPS

• Const APP_STYLE_STEPS: Object Gradient classes.

Type declaration

Name	Type
`min`	`2`
`max`	`7`

APP_STYLE_LINKED_OBJECTS

• Const APP_STYLE_LINKED_OBJECTS: 100 Objects one batched style value read names (map values, series fields, media URLs, linked pages): a layer reads them for every object it loads, in batches of this size, one reactive query per batch.

APP_LINKED_PAGE

• Const APP_LINKED_PAGE: 50 Linked objects linkedPages reads per object, at most.

APP_LINKED_FIELDS

• Const APP_LINKED_FIELDS: 4 Properties of each linked object linkedPages copies, at most.

APP_LINKED_BYTES

• Const APP_LINKED_BYTES: 8388608 Encoded bytes linkedPages reads in all (8 MiB), shared evenly by the objects it names: a page past its share ends early and is not complete.

APP_STYLE_RADIUS_METRES

• Const APP_STYLE_RADIUS_METRES: 100000 Largest circle a radius style draws, in metres (100 km).

APP_STYLE_MAX_SIZE

• Const APP_STYLE_MAX_SIZE: 64 Largest marker, line or icon size in CSS pixels.

APP_STYLE_MAX_TIME_MS

• Const APP_STYLE_MAX_TIME_MS: 604800000 Longest time buffer or fade: the series window bound, 7 days.

APP_MEDIA_ICON_BYTES

• Const APP_MEDIA_ICON_BYTES: 262144 Largest image file a map draws as an icon, in bytes (256 KiB).

APP_MEDIA_ICON_TYPES

• Const APP_MEDIA_ICON_TYPES: readonly ["image/png", "image/jpeg", "image/webp"] The image types a map draws as icons.

APP_MEDIA_IDS

• Const APP_MEDIA_IDS: 100 Objects one mediaFiles call reads.

APP_MEDIA_ROUTE

• Const APP_MEDIA_ROUTE: "/app/media" The application’s media route (appMediaHttp, mounted under the deployment’s HTTP actions): GET /app/media?collection=&id=&property= with the reader’s token as a Bearer authorization, re-reading the object under the reader’s rules on every request.

APP_MEDIA_RANGE_BYTES

• Const APP_MEDIA_RANGE_BYTES: 1048576 Bytes one media response serves: a whole file or one Range past it is refused bound_exceeded (media_range), never truncated. Above the largest tile and directory a map reads by range, and every icon.

APP_MEDIA_LAYER_IMAGES

• Const APP_MEDIA_LAYER_IMAGES: 64 Distinct images one map layer draws; the rest draw without their image and the layer says how many.

APP_MEDIA_IMAGERY_BYTES

• Const APP_MEDIA_IMAGERY_BYTES: 33554432 Bytes of one imagery archive the media route serves.

APP_MEDIA_VECTOR_BYTES

• Const APP_MEDIA_VECTOR_BYTES: 33554432 Bytes of one map archive the media route serves (a dataset’s geometry as vector or raster tiles, media: { kind: "vector" }).

APP_MEDIA_LAYER_IMAGERY

• Const APP_MEDIA_LAYER_IMAGERY: 16 Rasters one map layer draws; the rest draw as footprints and are counted.

APP_MEDIA_IMAGERY_TYPE

• Const APP_MEDIA_IMAGERY_TYPE: "application/vnd.pmtiles" The media type of an imagery archive (PMTiles); like an icon’s, a parameter may tag the upload.

MAP_LAYERS

• Const MAP_LAYERS: 16 Layers one map holds.

MAP_ANNOTATIONS

• Const MAP_ANNOTATIONS: 64 Items one annotation layer holds.

MAP_ANNOTATION_POSITIONS

• Const MAP_ANNOTATION_POSITIONS: 512 Positions one annotation’s geometry holds.

MAP_ANNOTATION_TEXT

• Const MAP_ANNOTATION_TEXT: 200 Characters of one annotation’s text.

MAP_PARAMETERS

• Const MAP_PARAMETERS: 8 Parameters one template declares.

MAP_PARAMETER_OBJECTS

• Const MAP_PARAMETER_OBJECTS: 100 Objects one objects parameter, or one fixed object set, names.

MAP_PARAMETER_FILTERS

• Const MAP_PARAMETER_FILTERS: 8 Filters bound to parameters in one layer scope.

SAVED_MAPS

• Const SAVED_MAPS: 50 Saved maps (templates included) one member owns.

MAX_SHARED_MAPS_PER_OWNER

• Const MAX_SHARED_MAPS_PER_OWNER: 20 Saved maps one member shares.

MAX_LISTED_SHARED_MAPS

• Const MAX_LISTED_SHARED_MAPS: 50 Shared maps one workspace-state read lists, newest first.

MAP_SAVE_BYTES

• Const MAP_SAVE_BYTES: 16384 Encoded bytes of one saved map.

MAP_SERIES_PINS

• Const MAP_SERIES_PINS: 8 Series one map pins to its series panel.

MAP_SERIES_BUCKETS

• Const MAP_SERIES_BUCKETS: 200 Buckets a series chart of the map draws at most, and by default (settings.seriesBuckets, 1 to this): the chart asks for seriesMeasurePoints(buckets) points.

SERIES_LATEST_IDS

• Const SERIES_LATEST_IDS: 100 Ids one seriesLatest request reads.

APP_MAP_UNITS

• Const APP_MAP_UNITS: readonly AppMapUnits[]

MAP_EDITORS

• Const MAP_EDITORS: 20 People one saved map or overlay layer names as its editors.

APP_TRACK_INTERPOLATIONS

• Const APP_TRACK_INTERPOLATIONS: readonly ["linear", "previous"] The interpolations a layer’s track presentation offers.

MAP_TILE_OBJECTS

• Const MAP_TILE_OBJECTS: 1000 Features one object tile draws; a tile holding more draws its count.

MAP_TILE_BYTES

• Const MAP_TILE_BYTES: 1048576 Encoded bytes of one object tile’s features (1 MiB).

MAP_TILE_READ_BYTES

• Const MAP_TILE_READ_BYTES: 4194304 Bytes of objects one object tile’s index reads may return before it stops reading (4 MiB): with the index’s own byte bound per read, the tile stays within one query’s read limit.

MAP_TILE_COLUMNS

• Const MAP_TILE_COLUMNS: 8 Properties one object tile copies into its features.

MAP_TILE_MAX_ZOOM

• Const MAP_TILE_MAX_ZOOM: 22 Deepest zoom an object tile is read at.

APP_MARKDOWN_LENGTH

• Const APP_MARKDOWN_LENGTH: 16000 Characters one Markdown text may hold; longer text is not parsed.

APP_INTENTS

• Const APP_INTENTS: readonly ["neutral", "info", "success", "warning", "danger"] The existing closed intent vocabulary, shared by declarations and values.

APP_OBSERVE_OBJECTS_MAX

• Const APP_OBSERVE_OBJECTS_MAX: 256 Objects one observation lists.

APP_OBSERVE_PROPERTIES_MAX

• Const APP_OBSERVE_PROPERTIES_MAX: 10 Properties whose values one observation returns per object.

POINT_READ_OBJECTS

• Const POINT_READ_OBJECTS: 100 The most objects one labels or objects call resolves, whatever their cost.

SERIES_MAX_POINTS

• Const SERIES_MAX_POINTS: 2000 Largest max_points a track request may ask for.

SERIES_DEFAULT_POINTS

• Const SERIES_DEFAULT_POINTS: 500 Points a track carries when the request names none.

SERIES_MAX_WINDOW_MS

• Const SERIES_MAX_WINDOW_MS: 604800000 Widest closed track window, in milliseconds (seven days).

SERIES_MAX_LOG

• Const SERIES_MAX_LOG: 50 Most reports one observation log carries.

SERIES_FIELDS_BYTES

• Const SERIES_FIELDS_BYTES: 16384 Most bytes of one report’s disclosed fields (their Bijection JSON).

SERIES_SEARCH_WINDOW_MS

• Const SERIES_SEARCH_WINDOW_MS: 86400000 Widest track search window, in milliseconds (one day).

SERIES_SEARCH_LIMIT

• Const SERIES_SEARCH_LIMIT: 100 Most objects one track search names.

SERIES_ENTRIES_PAGE

• Const SERIES_ENTRIES_PAGE: 500 Most reports one page of a series’ entries carries.

SERIES_ENTRIES_WINDOW_MS

• Const SERIES_ENTRIES_WINDOW_MS: 2678400000 Widest window a series’ entries are paged over, in milliseconds (31 days).

SERIES_MEASURES

• Const SERIES_MEASURES: 8 Most measures one series property declares, beside the built-ins.

SERIES_LATEST_MEASURES

• Const SERIES_LATEST_MEASURES: 4 Most measures one seriesLatest call reads per object.

SERIES_BUILTIN_MEASURES

• Const SERIES_BUILTIN_MEASURES: readonly [{ name: "speedMps" = “speedMps”; label: "Speed" = “Speed”; unit: "m/s" = “m/s” }, { name: "headingDegrees" = “headingDegrees”; label: "Heading" = “Heading”; unit: "°" = ”°” }, { name: "altitudeMetres" = “altitudeMetres”; label: "Altitude" = “Altitude”; unit: "m" = “m” }] The measures every report carries, with their labels and units.

APP_INTERPOLATION_MODES

• Const APP_INTERPOLATION_MODES: readonly ["linear", "nearest", "previous", "next", "none"] How a position or measure between two reports is estimated (the modes of @bijectionhq/geometry/movement).

SERIES_ANALYSIS_WINDOW_MS

• Const SERIES_ANALYSIS_WINDOW_MS: 864000000 Widest range one series analysis (seriesWindows, seriesChart, seriesSignal) reads, in milliseconds (ten days). The native read under it is bounded by stored hour blocks (SERIES_READ_HEADERS; a block never spans a UTC hour, so continuous data reaches the bound after about 10.7 days) and, for a chart or a signal, by decoded samples (SERIES_READ_EVENTS). A range within ten days can still pass either bound (uncompacted hours hold several blocks, a dense series more samples): it is then refused, bound_exceeded, and never answered in part.

SERIES_READ_HEADERS

• Const SERIES_READ_HEADERS: 256 Stored blocks one native series read considers (series_read_headers).

SERIES_READ_EVENTS

• Const SERIES_READ_EVENTS: 16384 Samples one native series read decodes (series_read_events; also at most 8 MiB decoded).

SERIES_MAX_WINDOWS

• Const SERIES_MAX_WINDOWS: 2000 Most windows one seriesWindows answers (series_windows).

SERIES_CHART_MIN_POINTS

• Const SERIES_CHART_MIN_POINTS: 4 Fewest points a seriesChart asks for: each bucket keeps up to four (its first, last, lowest and highest samples), so a chart of max_points has floor(max_points / 4) buckets. The most is SERIES_MAX_POINTS.

SERIES_WINDOW_UNITS

• Const SERIES_WINDOW_UNITS: readonly ["second", "minute", "hour", "day", "week", "month", "quarter", "year"] The calendar units of seriesWindows, in UTC.

SERIES_SIGNAL_INTERPOLATIONS

• Const SERIES_SIGNAL_INTERPOLATIONS: readonly ["previous", "linear", "interval"] How seriesSignal weighs time between two samples: the earlier value held, or a straight line between them.

SERIES_FLEET_IDS

• Const SERIES_FLEET_IDS: 32 At most this many objects one fleet ranking reads.

APP_SERIES_STYLE_DISPLAYS

• Const APP_SERIES_STYLE_DISPLAYS: readonly ["points", "icons", "track", "breadcrumbs"] Displays a series type’s default style may declare.

MAX_SHARE_PEOPLE

• Const MAX_SHARE_PEOPLE: 25 People one saved view or graph is shared with by name.

MAX_SHARED_VIEWS_PER_OWNER

• Const MAX_SHARED_VIEWS_PER_OWNER: 10 Views one member shares with every member. Sharing is metered per owner, so no member uses up general access for the others.

MAX_SHARED_GRAPHS_PER_OWNER

• Const MAX_SHARED_GRAPHS_PER_OWNER: 10 Graphs one member shares with every member, metered apart from views.

MAX_LISTED_PERSON_SHARES

• Const MAX_LISTED_PERSON_SHARES: 100 Items shared with the caller by name that one workspace-state read lists, most recently granted first; beyond them the listing says it is incomplete.

MAX_LISTED_SHARED_GRAPHS

• Const MAX_LISTED_SHARED_GRAPHS: 50 Graphs other members share with every member that one workspace-state read lists, most recently created first.

APP_TIME_UNITS

• Const APP_TIME_UNITS: readonly ["second", "minute", "hour", "day", "week", "month", "quarter", "year"] UTC bucket units in increasing width. Weeks do not refine calendar months. Quarter and year are read-time folds, never additional maintained totals.

Functions

isArgumentReference

▸ isArgumentReference(value): boolean

Parameters

Name	Type
`value`	`string`

Returns

boolean

argumentValueIssues

▸ argumentValueIssues(value, validator): ArgumentValueIssue[] Check exact decoded values against an admitted schema. The backend still checks table identity, authorization and business rules. Work is bounded to 4096 nodes, 32 levels and 128 issues.

Parameters

Name	Type
`value`	`unknown`
`validator`	`ValidatorJSON`

Returns

ArgumentValueIssue[]

operationArgumentIssues

▸ operationArgumentIssues(error): ArgumentValueIssue[] Read structured native operation validation data, without interpreting error wording.

Parameters

Name	Type
`error`	`unknown`

Returns

ArgumentValueIssue[]

appBoardFields

▸ appBoardFields(collection): AppBoardField[]

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"validator_json"` \| `"properties"`>

Returns

AppBoardField[]

appBoardField

▸ appBoardField(collection, name?): AppBoardField | undefined The explicit field, else the declared queue’s status, else the first schema category. An unavailable explicit field is refused, not replaced.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"validator_json"` \| `"properties"` \| `"worklist"`>
`name?`	`string`

Returns

AppBoardField | undefined

appBoundExceeded

▸ appBoundExceeded(bound, limit, message): BijectionError<AppBoundRefusal> The one constructor of an AppBoundRefusal: a BijectionError carrying it as data. Callers throw it.

Parameters

Name	Type
`bound`	`string`
`limit`	`number`
`message`	`string`

Returns

BijectionError<AppBoundRefusal>

isAppBoundRefusal

▸ isAppBoundRefusal(error, bound?): boolean Whether error is an AppBoundRefusal (of bound, when given), read from its data only, never its message.

Parameters

Name	Type
`error`	`unknown`
`bound?`	`string`

Returns

boolean

appInvalidRequest

▸ appInvalidRequest(message): BijectionError<AppInvalidRequest> The one constructor of an AppInvalidRequest: a BijectionError carrying it as data. Callers throw it.

Parameters

Name	Type
`message`	`string`

Returns

BijectionError<AppInvalidRequest>

isAppInvalidRequest

▸ isAppInvalidRequest(error): boolean Whether error is an AppInvalidRequest, read from its data only, never its message.

Parameters

Name	Type
`error`	`unknown`

Returns

boolean

appValidateCadence

▸ appValidateCadence(cadence, allowed): asserts cadence is AppCadence Refuse, by name, a cadence that is malformed or that this owner does not offer: kinds lists the kinds it accepts, and minMinutes/maxMinutes bound an every interval (minMinutes defaults to 1).

Parameters

Name	Type
`cadence`	`unknown`
`allowed`	`Object`
`allowed.kinds`	readonly `AppCadence`[`"kind"`][]
`allowed.minMinutes?`	`number`
`allowed.maxMinutes?`	`number`

Returns

asserts cadence is AppCadence

appNextOccurrence

▸ appNextOccurrence(cadence, timeZone, afterMs): number The first boundary of cadence strictly after afterMs, in exact epoch milliseconds. every ignores timeZone; the calendar kinds read the wall clock of timeZone (UTC or an IANA zone, see appIsTimeZone).

Parameters

Name	Type
`cadence`	`AppCadence`
`timeZone`	`string`
`afterMs`	`number`

Returns

number

appCommentsPlan

▸ appCommentsPlan(types, collection, operations, people): AppCommentsPlan | null Check a collection’s comments declaration against the collections and operations served to this caller, and say what it resolves to; null when the collection declares none. Throws, naming the declaration, when: the relation is not incoming to the comment collection; the body, author or date property is missing or of the wrong type; replies do not form a relation of the comment collection to itself, the reply count is not a number, or the post operation’s parent argument is not an optional reference to a comment; the author is not one of the people; or the edit operation does not target the comment collection, or its text argument or the edited property is missing. What discovery withholds from this caller is not checked: an operation they are not served (absent from their catalog, the workspace offers no form for it), and with mentions the author’s reference when people, the people collection served to them, is undefined. The application builder serves no discussion whose comment collection the caller is not served, and refuses mentions without people for every caller.

Parameters

Name	Type
`types`	readonly `AppCollection`[]
`collection`	`AppCollection`
`operations`	readonly `AppOperation`[]
`people`	`string` \| `undefined`

Returns

AppCommentsPlan | null

appMentionLabel

▸ appMentionLabel(name): string A label a token can carry: no brackets or line breaks, spaces collapsed, at most 80 characters; a name with nothing left is “person”.

Parameters

Name	Type
`name`	`string`

Returns

string

appMentionToken

▸ appMentionToken(label, id): string The token that mentions person id, labelled with label.

Parameters

Name	Type
`label`	`string`
`id`	`string`

Returns

string

appMentionText

▸ appMentionText(text): string text with each mention (appMentions) shown as @label: a notice, a preview or any other plain rendering. A token that is no mention stays as written, as the comment shows it.

Parameters

Name	Type
`text`	`string`

Returns

string

appCanonicalMentions

▸ appCanonicalMentions(text, resolve): Promise<AppCanonicalMentions> The body as a program stores it: every mention’s label rewritten to the name resolve reads for its person, in the same transaction, and the distinct people mentioned, in order. Refuses a mention whose person resolve does not answer (null), more than APP_MENTIONS_MAX distinct people, a stored body longer than APP_MARKDOWN_LENGTH, and a name that would change which tokens the stored body mentions (a backtick in it closing a code span, say): the stored body mentions exactly the people returned, each under the name read.

Parameters

Name	Type
`text`	`string`
`resolve`	(`id`: `string`) => `Promise`<`string` \| `null`>

Returns

Promise<AppCanonicalMentions>

encodeAppCursor

▸ encodeAppCursor(cursor): string The text of cursor: ${tag}:${payload}.

Parameters

Name	Type
`cursor`	`AppCursor`

Returns

string

decodeAppCursor

▸ decodeAppCursor(text): AppCursor | null The cursor text encodes; null for null or "" (the first page). A malformed or over-long cursor is refused with invalid_request, never a restart.

Parameters

Name	Type
`text`	`string` \| `null` \| `undefined`

Returns

AppCursor | null

decodeAppCursorOf

▸ decodeAppCursorOf<K>(text, ...kinds): Extract<AppCursor, { kind: K }> | null The cursor text encodes when it is of kind, else a malformed request (a cursor of another reader’s pages).

Type parameters

Name	Type
`K`	extends `AppCursor`[`"kind"`]

Parameters

Name	Type
`text`	`string` \| `null` \| `undefined`
`...kinds`	`K`[]

Returns

Extract<AppCursor, { kind: K }> | null

appPageRestart

▸ appPageRestart(message): BijectionError<AppPageRestart> The one constructor of an AppPageRestart.

Parameters

Name	Type
`message`	`string`

Returns

BijectionError<AppPageRestart>

isAppPageRestart

▸ isAppPageRestart(error): boolean Whether a failed page read asks its reader to start again from the first page (AppPageRestart), read from data.code only.

Parameters

Name	Type
`error`	`unknown`

Returns

boolean

readAppNativePage

▸ readAppNativePage<T>(query, opts, kind?): Promise<PaginationResult<T>> One native page read through the application cursor codec: opts’ cursors are application cursors of kind (native, or walk for a region walked in a view’s order), decoded to the inherited cursor the engine pages with, and the page’s continueCursor is encoded again. A cursor of another kind is invalid_request; an inherited InvalidCursor the engine raises becomes the typed appPageRestart. Every application page over a native range is read here.

Type parameters

Name
`T`

Parameters

Name	Type	Default value
`query`	`Object`	`undefined`
`query.paginate`	(`opts`: `PaginationOptions` & { `maximumRowsRead?`: `number` ; `maximumBytesRead?`: `number` }) => `Promise`<`PaginationResult`<`T`>>	`undefined`
`opts`	`PaginationOptions` & { `maximumRowsRead?`: `number` ; `maximumBytesRead?`: `number` }	`undefined`
`kind`	`"native"` \| `"walk"` \| `"series"`	`"native"`

Returns

Promise<PaginationResult<T>>

defineDataRelease

▸ defineDataRelease(options): DataReleaseDefinition Defines a reviewed derivation. Queries return {key, value} rows; the engine inserts only allowlisted rows and fields into the ordinary root destination. It binds installed code itself, including helpers and nested components. Changing any part requires a new review.

Parameters

Name	Type
`options`	`Object`
`options.component?`	`string`
`options.is_standing?`	`boolean`
`options.query`	`string`
`options.args`	`Record`<`string`, `Value`>
`options.destination_table`	`string`
`options.rows`	readonly `string`[]
`options.fields`	readonly `string`[]

Returns

DataReleaseDefinition

approveDataRelease

▸ approveDataRelease(deployment, token, options): Promise<{ id: string ; code: string }> Review one epoch, or a standing program when explicitly declared, as the person holding approve on the source’s data_release permission resource. Read and administration do not confer this authority; delegated identities cannot review.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`options`	`Object`
`options.source`	`DataReleaseSource`
`options.definition`	`DataReleaseDefinition`
`options.beneficiary`	`string`
`options.expires_at`	`Date`

Returns

Promise<{ id: string ; code: string }>

revokeDataRelease

▸ revokeDataRelease(deployment, token, id): Promise<{ id: string ; is_revoked: boolean }> Revoke an unused review as its original approver. Accepted copies persist.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`id`	`string`

Returns

Promise<{ id: string ; is_revoked: boolean }>

executeDataRelease

▸ executeDataRelease(deployment, token, options): Promise<DataReleaseReceipt> Produce a new epoch with current reads and approval authority. Single-use reviews are consumed atomically. Standing reviews stay revocable and recheck current authority on every execution; their projection keeps row identity. A request identifies this exact acceptance; do not reuse it for different definitions or approval IDs.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`options`	`Object`
`options.definition`	`DataReleaseDefinition`
`options.approvals`	{ `source`: `DataReleaseSource` ; `id`: `string` }[]
`options.request`	`string`

Returns

Promise<DataReleaseReceipt>

inspectDataRelease

▸ inspectDataRelease(deployment, token, id): Promise<{ epoch: string ; approvals: string[] ; actor: string ; request: string ; definition: DataReleaseDefinition ; code: string ; output_ids: string[] }> Inspect your accepted release under current source access. The audit response includes released IDs and the reviewed contract, never private read demands or source values.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`id`	`string`

Returns

Promise<{ epoch: string ; approvals: string[] ; actor: string ; request: string ; definition: DataReleaseDefinition ; code: string ; output_ids: string[] }>

simulateReleaseAccess

▸ simulateReleaseAccess(deployment, token, options): Promise<ReleaseAccessSimulation> Explain named clean-born containers and compare readers under current source policies with selected requirements removed hypothetically. Requires release authority for every label, supplies no content, and changes no state. Protected births and missing names have the same refusal. This comparison does not assert that a reviewed query can currently produce a release.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`options`	`Object`
`options.containers`	`DataReleaseContainer`[]
`options.readers`	`Record`<`string`, `unknown`>[]
`options.remove_requirements`	`DataReleaseSource`[]

Returns

Promise<ReleaseAccessSimulation>

appDecimalCoefficient

▸ appDecimalCoefficient(text, scale): bigint Parse a decimal without binary floating point or rounding.

Parameters

Name	Type
`text`	`string`
`scale`	`number`

Returns

bigint

appDecimalText

▸ appDecimalText(coefficient, scale): string Canonical decimal text from an exact coefficient.

Parameters

Name	Type
`coefficient`	`bigint`
`scale`	`number`

Returns

string

appDecimalScale

▸ appDecimalScale(collection, field?): number | undefined The field’s one admitted decimal scale, shared by every aggregate.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"aggregates"`>
`field?`	`string`

Returns

number | undefined

appSummaryMeasure

▸ appSummaryMeasure(group): bigint | string | null An exact display value: int64 or canonical decimal text.

Parameters

Name	Type
`group`	`Pick`<`AppSummary`[`"groups"`][`number`], `"sum"` \| `"decimal"`>

Returns

bigint | string | null

appGeometryValidator

▸ appGeometryValidator(types, declared?): VObject<any, any> | VUnion<any, any> The one constructor of a geometry validator: an object { type: v.literal(t), coordinates } per declared type (a union when several), each carrying declaration in its validator JSON (geometry: { profile, size }). The engine admits every value of such a validator under that profile and tier wherever it checks a value: function arguments and returns, and every schema-enforced table write. @bijectionhq/datasets/geometry geoShape/geoPoint are its public spelling.

Parameters

Name	Type
`types`	readonly `AppGeometryType`[]
`declared`	`Partial`<`AppGeometryDeclaration`>

Returns

VObject<any, any> | VUnion<any, any>

appGeometryDeclaration

▸ appGeometryDeclaration(json): AppGeometryDeclaration | null The declaration every member of a geometry validator JSON carries, or null when a member carries none or the members disagree (then it is not a geometry validator).

Parameters

Name	Type
`json`	`ValidatorJSON`

Returns

AppGeometryDeclaration | null

appGeometryTypes

▸ appGeometryTypes(json): AppGeometryType[] | null The geometry types a validator declares, in canonical order, or null for any other shape. A geometry validator is one { type, coordinates } object, or a union of them, built by appGeometryValidator: type is a GeoJSON type literal (each at most once), coordinates nests arrays of numbers exactly as that type does, and every member carries the same geometry declaration. Extra fields, optional members, other members and a structurally identical object without the declaration are not geometry.

Parameters

Name	Type
`json`	`ValidatorJSON`

Returns

AppGeometryType[] | null

appGeometryProperty

▸ appGeometryProperty(json): { types: AppGeometryType[] ; nullable: boolean ; is_position?: boolean } & AppGeometryDeclaration | null A property validator as a geometry property: its declared types, whether it admits null, and its declared profile and size tier, or null when it is not a geometry validator. v.null() may be one member of the union (v.union(geoPoint(), v.null())), nested unions are flattened, and nothing else is admitted.

Parameters

Name	Type
`json`	`ValidatorJSON`

Returns

{ types: AppGeometryType[] ; nullable: boolean ; is_position?: boolean } & AppGeometryDeclaration | null

appValueAtPath

▸ appValueAtPath(object, path): unknown The value at a dot-separated field path of a document, or undefined where the path is absent.

Parameters

Name	Type
`object`	`unknown`
`path`	`string`

Returns

unknown

appGeometryAtPath

▸ appGeometryAtPath(json, path): NonNullable<ReturnType<typeof appGeometryProperty>> The geometry property at a dot-separated field path of a document validator, as a spatial index over that path reads it: the path is walked through object validators and through each member of a union (a series resolution’s event, empty or conflict, say). A member without the path, an optional field on it, or a null-only leaf makes the property nullable. Every non-null member holding the path must be one geometry or Position meaning (appGeometryProperty) and all must agree; otherwise this throws.

Parameters

Name	Type
`json`	`ValidatorJSON`
`path`	`string`

Returns

NonNullable<ReturnType<typeof appGeometryProperty>>

isAppRegionRefusal

▸ isAppRegionRefusal(error): boolean Whether a failed read refused an object region (AppRegionRefusal).

Parameters

Name	Type
`error`	`unknown`

Returns

boolean

appWithinError

▸ appWithinError(within): string | null Why within is not an admissible AppWithin, or null.

Parameters

Name	Type
`within`	`unknown`

Returns

string | null

appNearestError

▸ appNearestError(nearest): string | null Why nearest is not an admissible AppNearest, or null.

Parameters

Name	Type
`nearest`	`unknown`

Returns

string | null

appCellGroupingError

▸ appCellGroupingError(cells): string | null Why cells is not an admissible AppCellGrouping, or null.

Parameters

Name	Type
`cells`	`unknown`

Returns

string | null

appRegionError

▸ appRegionError(region): string | null Why region is not an admissible AppRegion, or null when it is. This checks shape and bounds only (finite WGS84 numbers, closed rings of at least four positions, at most APP_REGION_VERTICES positions); the program’s spatial index applies the full geometry profile.

Parameters

Name	Type
`region`	`unknown`

Returns

string | null

appMapViewError

▸ appMapViewError(map): string | null Why map is not an admissible AppMapView, or null.

Parameters

Name	Type
`map`	`unknown`

Returns

string | null

appGeometryFields

▸ appGeometryFields(collection): AppGeometryField[] The geometry fields of a collection, in property name order: native geometry meaning from the served catalog (or the validator when no catalog is supplied), plus declared derived geometry, H3 and geohash fields. Presentation properties can label native geometry but cannot change its meaning. Name order is the one order the served catalog carries, since properties crosses the wire as a Bijection object, whose keys are sorted; the application’s own checks see the same order. A program states which field a map draws by default with defaultMapField. Throws when a declaration does not match the admitted validator, which the application refuses when it builds its catalog.

Without point, name is an admitted property whose validator is a geometry (appGeometryProperty).
A native spatial index over a nested path (current.event.values.position) adds that full path as a geometry field, its meaning resolved through the validator (appGeometryAtPath); appGeometryValue reads it at that path.
With point, name is a derived point that is NOT an admitted property, built from two admitted numeric properties (float64 or int64, optional or nullable allowed).
With line: { from, to }, name is a derived LineString that is NOT an admitted property, drawn from the value of from to the value of to: two distinct declared Point geometry fields of the same collection (admitted or derived points). It is null when either end is.
With format: "h3" or "geohash", name is an admitted string property (optional or nullable allowed) holding one cell id of that grid. Its geometry is the cell’s boundary, derived by the client (@bijectionhq/geometry/cells), so appGeometryValue is null for it; it may be a dimension and is never a spatial index. cell: { of } states that it stores the cell of of, a declared Point geometry field of the same collection (the program writes it; it is not checked per object): a map layer drawing of may count its objects per this stored cell. Without it the cell describes no other geometry.

This is the one resolver: the application’s checks, the explorer’s map and the object view’s map all read geometry through it.

Parameters

Name	Type
`collection`	`GeometryDeclarations`

Returns

AppGeometryField[]

appGeometryValue

▸ appGeometryValue(field, object): AppGeometry | null

Parameters

Name	Type
`field`	`AppGeometryField`
`object`	`Record`<`string`, `unknown`>

Returns

AppGeometry | null

appGeohashBox

▸ appGeohashBox(cell): AppBox | null The bounds of one geohash cell (1 to 12 base32 characters), or null for a value that is not one.

Parameters

Name	Type
`cell`	`unknown`

Returns

AppBox | null

appCanonicalReach

▸ appCanonicalReach(cell): AppBox | null The reach of a shape’s canonical geohash cell (appCanonicalGeohash): the cell’s box grown east by one cell width and north by one cell height, within the world; the world for "". Every shape whose canonical cell is cell, or any cell starting with it, lies in this box. Null for a value that is not a geohash cell.

Parameters

Name	Type
`cell`	`unknown`

Returns

AppBox | null

appGeometryBox

▸ appGeometryBox(shape): AppBox | null The bounding box of a geometry’s positions, or null for no position.

Parameters

Name	Type
`shape`	`Object`
`shape.coordinates`	`unknown`

Returns

AppBox | null

appCanonicalGeohash

▸ appCanonicalGeohash(shape, precision?): string | null The canonical geohash cell of a stored shape, as a program writes it in a stored cell property declared cell: { of: <the shape property> }: the cell holding the south-west corner of the shape’s bounding box at the finest precision, at most precision, whose reach (appCanonicalReach: the cell grown by one cell east and north) holds that box. Each shape is counted once, by one cell, and lies in its cell’s reach wherever it is, so a shape crossing a cell edge stays in a cell of its own size: a shape is in the world’s cell, "", only when no precision-1 cell’s reach holds it (it is more than 45 degrees wide or tall). A cell’s shorter prefix is a coarser canonical cell of the same shape. Null for no shape.

Parameters

Name	Type	Default value
`shape`	{ `coordinates`: `unknown` } \| `null`	`undefined`
`precision`	`number`	`APP_CANONICAL_PRECISION`

Returns

string | null

appBoxHolds

▸ appBoxHolds(outer, inner): boolean Whether outer holds inner, boundary inclusive.

Parameters

Name	Type
`outer`	`AppBox`
`inner`	`AppBox`

Returns

boolean

appGraphStyleProperties

▸ appGraphStyleProperties(collection): { name: string ; kind: AppGraphPropertyKind }[] The properties of collection a graph may style its nodes by, in the order its admitted validator declares them. Only an admitted top-level property its presentation does not hide qualifies, and only when its stored value is one comparable scalar: a date or datetime is time, an int64 or float64 number, and a string, boolean or union of string and boolean literals (each optionally nullable) category. Geometry, JSON and grid cells, stored files, references to other objects (v.id) and derived entries (a point, line, cell or series) never qualify.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"validator_json"` \| `"properties"`>

Returns

{ name: string ; kind: AppGraphPropertyKind }[]

appRowSubjects

▸ appRowSubjects(collection, index?): number | null Subjects one visited row of collection costs through index (the default ordering when omitted): 0 when free or when its ranges fold, null when unbounded.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"read_cost"`>
`index?`	`string`

Returns

number | null

appObjectSubjects

▸ appObjectSubjects(collection): number | null Subjects one object of collection read by identity costs: 0 when free, null when unbounded.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"read_cost"`>

Returns

number | null

appPointReadLimit

▸ appPointReadLimit(collection): number Objects of collection one objects or labels call may resolve. A point read of a checked collection records two subjects per checked row, its demand and the row it found, within APP_READ_SUBJECT_BUDGET and at most 100 per call. An unbounded collection is given the view figure, which bounds the rows themselves but not obligations they restore. A caller with more objects splits them into calls of this size.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"read_cost"`>

Returns

number

appSearchMode

▸ appSearchMode(collection): AppSearchMode | undefined The collection’s search mode, or undefined when it declares no search.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"search"` \| `"search_indexes"`>

Returns

AppSearchMode | undefined

applicationOperation

▸ applicationOperation(operation): AppOperationAdapters Resolve the ordinary operation adapters from an admitted public contract. Invocation still verifies the expected digest and current permissions.

Parameters

Name	Type
`operation`	`AppOperation`

Returns

AppOperationAdapters

appExactQuotient

▸ appExactQuotient(numerator, denominator, digits?): Object numerator / denominator as a decimal string with at most digits fraction digits, computed on exact integers only (never through floating point). exact is true when the quotient terminates within digits; otherwise the text is rounded half to even and exact is false, so a surface can mark it approximate. Used for averages: sum / count.

Parameters

Name	Type	Default value
`numerator`	`bigint`	`undefined`
`denominator`	`bigint`	`undefined`
`digits`	`number`	`2`

Returns

Object

Name	Type
`text`	`string`
`exact`	`boolean`

appRelativeRangeError

▸ appRelativeRangeError(value): string | null Why value is not an AppRelativeRange, or null.

Parameters

Name	Type
`value`	`unknown`

Returns

string | null

appIsUtcDay

▸ appIsUtcDay(day): day is string Whether day is a calendar day YYYY-MM-DD, the form of asOf.

Parameters

Name	Type
`day`	`unknown`

Returns

day is string

appUtcDay

▸ appUtcDay(ms): string The UTC calendar day YYYY-MM-DD holding the instant ms: the asOf a reader passes for “today” is appUtcDay(Date.now()).

Parameters

Name	Type
`ms`	`number`

Returns

string

appRelativeBounds

▸ appRelativeBounds(range, asOf): Object The closed-open instants [from, to) a relative range selects when read on the UTC day asOf (YYYY-MM-DD), each a UTC midnight in exact epoch milliseconds, null for an open side. Weeks start on Monday and months on their first day: the calendar of AppTimeAxis, so a relative range, a histogram bucket and a custom day range select the same objects.

Parameters

Name	Type
`range`	`AppRelativeRange`
`asOf`	`string`

Returns

Object

Name	Type
`from`	`number` \| `null`
`to`	`number` \| `null`

appViewIsRelative

▸ appViewIsRelative(view): boolean Whether any filter of view — its filters, chart selections, condition groups or relationship clauses — is a relative date range, so every read of it names the day it is read on (asOf).

Parameters

Name	Type
`view`	`Pick`<`AppView`, `"filters"` \| `"analysisFilters"` \| `"groups"` \| `"related"`>

Returns

boolean

appInclusiveUpperBound

▸ appInclusiveUpperBound(max): bigint | number | null The exclusive upper bound of a between range equivalent to the inclusive maximum max: max + 1n for an int64, and the next float64 above max for a float64, found on its bits rather than by arithmetic, so [from, appInclusiveUpperBound(max)] selects exactly from <= value <= max. Null (an open upper side) when no larger value of the type exists.

Parameters

Name	Type
`max`	`bigint` \| `number`

Returns

bigint | number | null

appFavoriteKey

▸ appFavoriteKey(item): string A favorite’s identity: two entries with one key are one favorite.

Parameters

Name	Type
`item`	`AppFavorite`

Returns

string

graphSaveBound

▸ graphSaveBound(graph): number The encoded length graph can reach by dragging, hiding, collapsing and detaching alone: every node and note coordinate replaced by -100000, hidden by every node type and every note’s node by -1, then JSON.stringify(bijectionToJson(...)).length. Moving a node or a note, hiding a type and detaching a note are the only edits that lengthen an encoding without being checked (the tables are sorted, so removal never does, and collapsing a group swaps 0 for 1), so this is never below the actual encoded length of a valid graph and never below any length the graph reaches by those edits. saveGraph refuses above GRAPH_SAVE_LIMIT on this measure, and a workspace admits objects, styles, notes and groups under the same function, so a canvas it holds always saves.

Parameters

Name	Type
`graph`	`AppGraph`

Returns

number

appQueryScope

▸ appQueryScope(view, asOf?): Omit<AppBrowseArgs, "paginationOpts"> The canonical query scope shared by tables, charts, and exports. asOf is carried only for a view that holds a relative date range, so an absolute view’s scope (and every cache key built from it) does not change with the day.

Parameters

Name	Type
`view`	`AppView`
`asOf?`	`string`

Returns

Omit<AppBrowseArgs, "paginationOpts">

sendAccessRequestAction

▸ sendAccessRequestAction(deployment, token, action): Promise<AppAccessRequestReceipt> Sends one access request write with the caller’s own bearer token. deployment is the deployment URL the Bijection client uses. Throws the engine’s refusal message when the write is refused.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`action`	`AppAccessRequestAction`

Returns

Promise<AppAccessRequestReceipt>

requestResourceAccess

▸ requestResourceAccess(deployment, token, requests, request): Promise<AppAccessRequestReceipt> Request role on one object for beneficiary (the caller’s workspace person, unless they request for someone else they may), with the reason a reviewer will read. The request grants nothing until a reviewer approves it; approval then writes exactly this grant.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`requests`	`ResourceRequestsTable`
`request`	`ResourceAccess` & { `reason`: `string` }

Returns

Promise<AppAccessRequestReceipt>

decideResourceAccessRequest

▸ decideResourceAccessRequest(deployment, token, requests, decision): Promise<AppAccessRequestReceipt> Approve or reject one pending resource request. The engine rechecks that it is pending, that the caller now holds the role’s grant permission and did not make it.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`requests`	`ResourceRequestsTable`
`decision`	`Object`
`decision.id`	`string`
`decision.decision`	`"approve"` \| `"reject"`
`decision.comment?`	`string`

Returns

Promise<AppAccessRequestReceipt>

withdrawResourceAccessRequest

▸ withdrawResourceAccessRequest(deployment, token, requests, id): Promise<AppAccessRequestReceipt> Withdraw the caller’s own pending resource request.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`requests`	`ResourceRequestsTable`
`id`	`string`

Returns

Promise<AppAccessRequestReceipt>

requestOperationAccess

▸ requestOperationAccess(deployment, token, request): Promise<AppAccessRequestReceipt> Request one workspace operation role for the caller’s stable person. Approval remains a separate native resource-request decision.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`request`	`Object`
`request.operation`	`Object`
`request.operation.component?`	`string`
`request.operation.operation`	`string`
`request.permission`	`AppRequestablePermission`
`request.reason`	`string`

Returns

Promise<AppAccessRequestReceipt>

runConnectionCheck

▸ runConnectionCheck(deployment, token, check): Promise<AppConnectionCheckResult> Executes the caller’s own recorded connection check request (requestConnectionCheck) with their own bearer token. deployment is the deployment URL the client uses. Running the same request again after a lost response finishes it or returns its recorded result. Throws the engine’s refusal message when the check is refused.

Parameters

Name	Type
`deployment`	`string`
`token`	`string`
`check`	`Object`
`check.source`	`string`
`check.request`	`string`

Returns

Promise<AppConnectionCheckResult>

applicationApi

▸ applicationApi(module?): Object References use the same public query transport as any customer application.

Parameters

Name	Type	Default value
`module`	`string`	`"application"`

Returns

Object

Name	Type	Description
`connectionPage`	`FunctionReference`<`"query"`, `"public"`, { `organization`: `undefined` \| `null` \| `string` ; `owner`: `undefined` \| `"personal"` \| `"organization"` ; `clientSession`: `undefined` \| `string` ; `integration`: { module: string; export: string; } ; `paginationOpts`: { id?: number; endCursor?: string \| null; maximumRowsRead?: number; maximumBytesRead?: number; numItems: number; cursor: string \| null; } }, `PaginationResult`<`ConnectionSummary`>, `undefined` \| `string`>	-
`connectionList`	`FunctionReference`<`"query"`, `"public"`, { `organization`: `undefined` \| `null` \| `string` ; `owner`: `undefined` \| `"personal"` \| `"organization"` ; `integration`: { module: string; export: string; } }, `ConnectionSummary`[], `undefined` \| `string`>	-
`connectionDetail`	`FunctionReference`<`"query"`, `"public"`, { `organization`: `undefined` \| `null` \| `string` ; `owner`: `undefined` \| `"personal"` \| `"organization"` ; `clientSession`: `undefined` \| `string` ; `integration`: { module: string; export: string; } ; `accountHandle`: `string` }, `null` \| `ConnectionStatus`, `undefined` \| `string`>	-
`scenarioMetadata`	`FunctionReference`<`"query"`, `"public"`, { `name`: `string` }, `null` \| `string` \| `number` \| `boolean` \| readonly `ScenarioMetadata`[] \| { `[key: string]`: `ScenarioMetadata` \| `undefined`; }, `undefined` \| `string`>	-
`scenarioModelPreflight`	`FunctionReference`<`"query"`, `"public"`, { `contract`: `string` }, `null`, `undefined` \| `string`>	-
`scenarioModelRead`	`FunctionReference`<`"query"`, `"public"`, { `name`: `string` ; `version`: `string` ; `contract`: `string` ; `input`: `any` }, `ModelInvocation`<`Value`> & { `calls`: `ModelCall`[] }, `undefined` \| `string`>	-
`scenarioModelProviders`	`FunctionReference`<`"query"`, `"public"`, { `contract`: `string` }, `null`, `undefined` \| `string`>	-
`scenarioModelValidate`	`FunctionReference`<`"query"`, `"public"`, { `rules`: `undefined` \| `string` ; `value`: `any` ; `validator`: `string` }, `null`, `undefined` \| `string`>	-
`scenarioModel`	`FunctionReference`<`"query"`, `"public"`, { `name`: `string` }, { `version`: `string` = specification.version; `contract`: `string` }, `undefined` \| `string`>	-
`scenarioInference`	`FunctionReference`<`"action"`, `"public"`, { `recover`: `undefined` \| `boolean` ; `simulation`: `undefined` \| { factorSeed?: string; clockMs: number; seed: string; } ; `name`: `string` ; `version`: `string` ; `contract`: `string` ; `input`: `any` ; `requestKey`: `string` }, `null` \| { `state`: `"unsupported"` } \| { `state`: `"invalid"` } \| { `implementation`: `string` ; `output`: `Value` ; `samplingSeed?`: `string` ; `calls`: `ModelCall`[] ; `state?`: `undefined` }, `undefined` \| `string`>	-
`operationReviewQueue`	`FunctionReference`<`"query"`, `"public"`, { `component?`: `string` ; `operation`: `string` ; `resourceType`: `string` ; `key`: `string` ; `cursor`: `null` \| `string` }, { `reviews`: `PendingOperationReview`[] ; `cursor`: `null` \| `string` ; `isComplete`: `boolean` }, `undefined` \| `string`>	-
`operationReview`	`FunctionReference`<`"query"`, `"public"`, { `component?`: `string` ; `reviewId`: `string` ; `includeProposal`: `boolean` }, `OperationReviewDetail`, `undefined` \| `string`>	-
`decideOperationReview`	`FunctionReference`<`"mutation"`, `"public"`, { `component?`: `string` ; `reviewId`: `string` ; `decision`: `"revoke"` \| `"approve"` }, `null`, `undefined` \| `string`>	-
`scenarios`	`FunctionReference`<`"query"`, `"public"`, {}, { `name`: `string` ; `cases`: `string`[] }[], `undefined` \| `string`>	-
`scenarioEvaluation`	`FunctionReference`<`"query"`, `"public"`, { `name`: `null` \| `string` ; `input`: `string` }, `string`, `undefined` \| `string`>	-
`scenarioRecipe`	`FunctionReference`<`"query"`, `"public"`, { `name`: `string` ; `caseName`: `string` }, `string`, `undefined` \| `string`>	-
`scenarioReportAccess`	`FunctionReference`<`"query"`, `"public"`, {}, `boolean`, `undefined` \| `string`>	-
`seriesErasure`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `request`: `string` }, `null` \| `SeriesErasureStatus`, `undefined` \| `string`>	-
`seriesEvents`	`FunctionReference`<`"query"`, `"public"`, { `fields`: `undefined` \| `string`[] ; `cursor`: `undefined` \| `string` ; `limit`: `undefined` \| `number` ; `direction`: `undefined` \| `"asc"` \| `"desc"` ; `collection`: `string` ; `from`: `bigint` ; `to`: `bigint` ; `series_id`: `string` }, `SeriesPage`<`SeriesEvent`<`Partial`<`Record`<`string`, `Value`>>>>, `undefined` \| `string`>	-
`seriesSamples`	`FunctionReference`<`"query"`, `"public"`, { `fields`: `undefined` \| `string`[] ; `cursor`: `undefined` \| `string` ; `limit`: `undefined` \| `number` ; `direction`: `undefined` \| `"asc"` \| `"desc"` ; `collection`: `string` ; `from`: `bigint` ; `to`: `bigint` ; `series_id`: `string` }, `SeriesPage`<`SeriesSample`<`Partial`<`Record`<`string`, `Value`>>>>, `undefined` \| `string`>	-
`seriesSummary`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `from`: `bigint` ; `to`: `bigint` ; `series_id`: `string` }, `SeriesRead`<`SeriesSummary`>, `undefined` \| `string`>	-
`branchAccounts`	`FunctionReference`<`"query"`, `"public"`, { `account`: `string` }, { `tokenIdentifier`: `string` ; `name`: `string` }[], `undefined` \| `string`>	-
`discover`	`FunctionReference`<`"query"`, `"public"`, `DiscoverArgs`, `DiscoveryPage`, `undefined` \| `string`>	-
`describe`	`FunctionReference`<`"query"`, `"public"`, { `ref`: `function: $\{string}\` \\| \`collection:$ {string}` \| `operation: $\{string}\` \\| \`relation:$ {string}` \| `interface:${string}` }, `DiscoveryDescription`, `undefined` \| `string`>	-
`argumentChoices`	`FunctionReference`<`"query"`, `"public"`, `ArgumentChoicesArgs`, `ArgumentChoicesPage`, `undefined` \| `string`>	-
`notifications`	`FunctionReference`<`"query"`, `"public"`, { `status`: `"all"` \| `"unread"` \| `"archived"` ; `kind?`: `string` ; `paginationOpts`: { `cursor`: `null` \| `string` ; `numItems`: `number` ; `endCursor?`: `null` \| `string` } }, `AppNotificationPage`, `undefined` \| `string`>	-
`updateNotification`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `is_read?`: `boolean` ; `is_archived?`: `boolean` }, `null`, `undefined` \| `string`>	-
`markNotificationsRead`	`FunctionReference`<`"mutation"`, `"public"`, { `ids`: `string`[] }, `null`, `undefined` \| `string`>	Mark 1 to 32 of the caller’s own notifications read in one transaction: all of them, or none when any id is not the caller’s or no longer resolves. Marking more is the caller’s continuation over the unread pages, one such call per page.
`series`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesArgs`, `AppSeriesResult`, `undefined` \| `string`>	One object’s declared series property: its latest point and, when `from` is given, a bounded track window (see AppSeriesArgs).
`seriesLatest`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesLatestArgs`, `AppSeriesLatest`, `undefined` \| `string`>	The latest point of several objects’ declared series property; objects the caller may not read are counted, not shown.
`seriesSearch`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesSearchArgs`, `AppSeriesSearchResult`, `undefined` \| `string`>	The objects whose track of a declared series property met a drawn area within a window; objects the caller may not read are counted.
`seriesPropertyPrepare`	`FunctionReference`<`"mutation"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `property`: `string` ; `from`: `bigint` ; `to`: `bigint` ; `kind`: `"summary"` \| `"signal_summary"` \| `"signal_windows"` \| `"windows"` \| `"chart"` \| `"signal"` \| `"signal_chart"` ; `max_points?`: `number` ; `every?`: `"year"` \| `"month"` \| `"day"` \| `"hour"` \| `"minute"` \| `"second"` \| `"week"` \| `"quarter"` ; `interpolation?`: `"previous"` \| `"linear"` \| `"interval"` ; `max_gap?`: `bigint` }, `string`, `undefined` \| `string`>	One measure of an object’s declared series property over a window, downsampled on the server with exact values (see AppSeriesMeasure).
`seriesPropertyAnalysis`	`FunctionReference`<`"query"`, `"public"`, { `analysis_id`: `string` }, `AppSeriesPropertyAnalysis`, `undefined` \| `string`>	-
`seriesProperty`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `property`: `string` ; `from`: `bigint` ; `to`: `bigint` ; `kind`: `"samples"` \| `"summary"` \| `"signal_summary"` \| `"signal_windows"` \| `"windows"` \| `"chart"` \| `"episodes"` \| `"signal"` \| `"events"` \| `"signal_chart"` ; `max_points?`: `number` ; `every?`: `"year"` \| `"month"` \| `"day"` \| `"hour"` \| `"minute"` \| `"second"` \| `"week"` \| `"quarter"` ; `interpolation?`: `"previous"` \| `"linear"` \| `"interval"` ; `max_gap?`: `bigint` ; `limit?`: `number` ; `cursor?`: `string` }, `AppSeriesPropertyRead`, `undefined` \| `string`>	-
`seriesMeasure`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesMeasureArgs`, `AppSeriesMeasure`, `undefined` \| `string`>	-
`seriesWindows`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesWindowsArgs`, `AppSeriesAnalysis`<`AppSeriesWindows`>, `undefined` \| `string`>	One measure of an object’s declared series property summarized exactly per calendar window over a bounded range (see AppSeriesWindows).
`seriesChart`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesChartArgs`, `AppSeriesAnalysis`<`AppSeriesChart`>, `undefined` \| `string`>	One measure over a bounded range reduced per bucket to its first, last, lowest and highest samples (see AppSeriesChart).
`seriesSignal`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesSignalArgs`, `AppSeriesAnalysis`<`AppSeriesSignal`>, `undefined` \| `string`>	One measure over a bounded range weighted by time: coverage, exact integral and means (see AppSeriesSignal).
`seriesExpression`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesExpressionArgs`, `AppSeriesAnalysis`<`AppSeriesExpression`>, `undefined` \| `string`>	One series expression over a bounded range: values, windows, a chart, a summary or a condition’s episodes (see AppSeriesExpression).
`seriesFleet`	`FunctionReference`<`"query"`, `"public"`, `AppSeriesFleetArgs`, `AppSeriesFleet`, `undefined` \| `string`>	Up to 32 objects ranked by one aggregate of a series expression (see AppSeriesFleet).
`facets`	`FunctionReference`<`"query"`, `"public"`, `AppFacetsArgs`, `AppFacets`, `undefined` \| `string`>	-
`placeSearch`	`FunctionReference`<`"mutation"`, `"public"`, { `text`: `string` }, { `id`: `string` }, `undefined` \| `string`>	Records a durable location search under the caller (1 to 200 characters); `placeResult` answers it.
`placeResult`	`FunctionReference`<`"query"`, `"public"`, { `id`: `string` }, `null` \| `AppPlaceSearch`, `undefined` \| `string`>	-
`placeReverse`	`FunctionReference`<`"mutation"`, `"public"`, { `point`: `number`[] }, { `id`: `string` }, `undefined` \| `string`>	Records a durable reverse-geocoding request for a WGS84 `[longitude, latitude]`; `placeResult` answers it with one place.
`placeOffering`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppPlaceOffering`, `undefined` \| `string`>	Whether location search is offered now, by which provider, and the operation an administrator sets it with.
`searchAroundFunction`	`FunctionReference`<`"query"`, `"public"`, { `name`: `string` ; `ids`: `string`[] }, `AppSearchAroundFunction`, `undefined` \| `string`>	A registered Search Around function from up to 50 starting objects, each starting and returned object read under the caller’s rules.
`objectives`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppObjective`[], `undefined` \| `string`>	The objectives the program declares (`defineApplication({ objectives })`).
`metrics`	`FunctionReference`<`"query"`, `"public"`, { `objective`: `string` ; `metrics`: `string`[] }, `AppMetricReadings`, `undefined` \| `string`>	One objective’s exact metric readings at one basis: compared across sibling branches, the scorecard.
`mapValues`	`FunctionReference`<`"query"`, `"public"`, { `name`: `string` ; `ids`: `string`[] }, { `values`: `Record`<`string`, `null` \| `string` \| `number`> ; `restricted`: `number` }, `undefined` \| `string`>	A registered map value for up to `appPointReadLimit` objects, each read under the caller’s rules first; refused ones are counted.
`mediaFiles`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `property`: `string` ; `ids`: `string`[] }, { `files`: `Record`<`string`, `null` \| `AppMediaFile`> ; `restricted`: `number` }, `undefined` \| `string`>	The files of a `media` property for up to 100 objects, each read under the caller’s rules first (refused ones counted): the media route path serving each (`appMediaHttp`), or null for no file or one its kind does not draw. Never a bearer URL.
`objectFiles`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `property`: `string` ; `ids`: `string`[] }, { `files`: `Record`<`string`, `null` \| `AppObjectFile`> ; `restricted`: `number` }, `undefined` \| `string`>	The files of a `media: { kind: "file" }` property for up to 100 objects, each object read under the caller’s rules first (refused ones counted): the protected file’s native binding (exact size, SHA-256, content type) and its declared name, or null for none or a file the storage owner does not open to the caller.
`mapArchive`	`FunctionReference`<`"query"`, `"public"`, { `key`: `string` }, `null` \| { `key`: `string` ; `label`: `string` ; `dataset`: `string` ; `column`: `string` ; `collection`: `string` ; `property`: `string` ; `id`: `null` \| `string` }, `undefined` \| `string`>	The object holding a declared map archive’s current version (an archive overlay’s key), or null when the key is not declared, its collection is not served to the caller, or nothing is recorded yet.
`mapArchiveStatus`	`FunctionReference`<`"query"`, `"public"`, { `key`: `string` }, `null` \| `AppMapArchiveStatus`, `undefined` \| `string`>	A declared map archive’s versions: who records them (the program’s tiling or an external producer), whether it follows its publications and whether the caller may tile it; null as `mapArchive` is.
`tileMapArchive`	`FunctionReference`<`"mutation"`, `"public"`, { `key`: `string` }, { `run`: `string` ; `version`: `string` }, `undefined` \| `string`>	Tiles a declared map archive’s newest published version and makes it follow the next ones on the caller’s behalf (administrators); refused for an archive an external producer records.
`hasRelation`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `relation`: `string` ; `targetId`: `string` }, `boolean`, `undefined` \| `string`>	-
`related`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `relation`: `string` ; `ids?`: `string`[] ; `where?`: `AppFilter`[] ; `order?`: `"asc"` \| `"desc"` ; `orderBy?`: `string` ; `paginationOpts`: { `cursor`: `null` \| `string` ; `numItems`: `number` ; `endCursor?`: `null` \| `string` } }, `AppRelatedPage`, `undefined` \| `string`>	-
`relatedWindow`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `relation`: `string` ; `ids?`: `string`[] ; `where?`: `AppFilter`[] ; `order?`: `"asc"` \| `"desc"` ; `orderBy?`: `string` ; `windowOpts`: `RelatedWindowOptions`<`string`> }, `AppRelatedWindowPage`, `undefined` \| `string`>	-
`searchAround`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `hops`: `AppSearchHop`[] }, `AppSearchAround`, `undefined` \| `string`>	One starting object’s bounded multi-hop Search Around.
`objects`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `ids`: `string`[] }, `AppObject`[], `undefined` \| `string`>	-
`labels`	`FunctionReference`<`"query"`, `"public"`, { `objects`: { `collection`: `string` ; `id`: `string` }[] }, `AppObjectLabel`[], `undefined` \| `string`>	-
`search`	`FunctionReference`<`"query"`, `"public"`, { `text`: `string` ; `collection?`: `string` ; `limit?`: `number` }, `AppSearchGroup`[], `undefined` \| `string`>	Every searchable type’s best matches, or with `collection` one searchable type’s, read with the whole read budget. `limit` is 1 to APP_SEARCH_LIMIT titles per type, 5 when omitted.
`analysis`	`FunctionReference`<`"query"`, `"public"`, `AppAnalysisArgs`, `AppAnalysis`, `undefined` \| `string`>	-
`summary`	`FunctionReference`<`"query"`, `"public"`, `AppSummaryArgs`, `AppSummary`, `undefined` \| `string`>	-
`workspaceState`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppWorkspaceState`, `undefined` \| `string`>	-
`saveView`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `name`: `string` ; `view`: `AppView` ; `revision`: `number` }, `null`, `undefined` \| `string`>	Create (`id` empty, `revision` 0) a private view, or replace a view’s name and definition at its current revision: the caller’s own, or one shared with them as an editor (it keeps its owner and sharing).
`deleteView`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `revision`: `number` }, `null`, `undefined` \| `string`>	-
`savedGraph`	`FunctionReference`<`"query"`, `"public"`, { `id`: `string` }, `AppSavedGraph`, `undefined` \| `string`>	-
`saveGraph`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `name`: `string` ; `graph`: `AppGraph` ; `revision`: `number` }, { `id`: `string` ; `revision`: `number` }, `undefined` \| `string`>	-
`deleteGraph`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `revision`: `number` }, `null`, `undefined` \| `string`>	-
`savedLineages`	`FunctionReference`<`"query"`, `"public"`, {}, `AppSavedLineage`[], `undefined` \| `string`>	The caller’s own saved lineages of the Dependencies page, at most SAVED_LINEAGES, in the order they were saved. They are private: no other member lists or opens them.
`saveLineage`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `name`: `string` ; `lineage`: `AppLineage` ; `revision`: `number` }, { `id`: `string` ; `revision`: `number` }, `undefined` \| `string`>	Create (`id` empty, `revision` 0) a private saved lineage, or replace the caller’s own at its current revision.
`deleteLineage`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `revision`: `number` }, `null`, `undefined` \| `string`>	-
`shares`	`FunctionReference`<`"query"`, `"public"`, { `id`: `string` }, `AppShares`, `undefined` \| `string`>	Who one of the caller’s own saved views or graphs is shared with.
`share`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `revision`: `number` ; `is_shared`: `boolean` ; `people`: `AppShareGrant`[] }, { `revision`: `number` }, `undefined` \| `string`>	Replace who one of the caller’s own saved views or graphs is shared with, at its current revision, all or nothing.
`savedMap`	`FunctionReference`<`"query"`, `"public"`, { `id`: `string` }, `AppSavedMap`, `undefined` \| `string`>	One saved map the caller may open: their own, or a shared one.
`saveMap`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `name`: `string` ; `document`: `AppMapDocument` ; `revision`: `number` ; `sharing`: `AppMapSharing` }, { `id`: `string` }, `undefined` \| `string`>	Create (`id` empty, `revision` 0) or replace a saved map at its current revision: the caller’s own, or one its sharing lets them edit (whose sharing they then pass back unchanged).
`deleteMap`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `revision`: `number` }, `null`, `undefined` \| `string`>	-
`savePreferences`	`FunctionReference`<`"mutation"`, `"public"`, { `preferences`: { `theme?`: `"system"` \| `"light"` \| `"dark"` ; `density?`: `"compact"` \| `"comfortable"` ; `locale?`: `string` ; `timeZone?`: `string` ; `recentObjects?`: { `collection`: `string` ; `id`: `string` }[] ; `favorites?`: `AppFavorite`[] ; `railGroups?`: `Record`<`string`, `boolean`> ; `graphStyles?`: `AppSavedGraphStyle`[] } ; `revision`: `number` }, `null`, `undefined` \| `string`>	-
`mapSettings`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppMapSettingsView`, `undefined` \| `string`>	The deployment’s map settings and the caller’s basemaps.
`saveMapSettings`	`FunctionReference`<`"mutation"`, `"public"`, { `settings`: `AppMapSettings` ; `revision`: `number` }, { `revision`: `number` }, `undefined` \| `string`>	Replace the deployment’s map settings at their current revision (administrators only).
`overlayLayers`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppOverlayListing`[], `undefined` \| `string`>	The caller’s overlay layers and the ones other members share.
`overlayLayer`	`FunctionReference`<`"query"`, `"public"`, { `id`: `string` }, `AppSavedOverlay`, `undefined` \| `string`>	-
`saveOverlayLayer`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `name`: `string` ; `overlay`: `AppOverlayLayer` ; `revision`: `number` ; `sharing`: `AppMapSharing` }, { `id`: `string` }, `undefined` \| `string`>	Create (`id` empty, `revision` 0) or replace an overlay layer at its current revision: the caller’s own, or one its sharing lets them edit (whose sharing they then pass back unchanged).
`deleteOverlayLayer`	`FunctionReference`<`"mutation"`, `"public"`, { `id`: `string` ; `revision`: `number` }, `null`, `undefined` \| `string`>	-
`mapTile`	`FunctionReference`<`"action"`, `"public"`, { `basemap`: `string` ; `z`: `number` ; `x`: `number` ; `y`: `number` }, `AppMapTile`, `undefined` \| `string`>	One tile of a basemap served through the deployment (a provider key the browser never sees); null when the provider has none there, a refusal when this tile cannot be served.
`objectTile`	`FunctionReference`<`"query"`, `"public"`, `AppObjectTileArgs`, `AppObjectTile`, `undefined` \| `string`>	One z/x/y tile of an objects map layer, read through the ordinary authorized browse: its objects’ simplified geometry and asked properties, or its count past `MAP_TILE_OBJECTS` or `MAP_TILE_BYTES`.
`linkedPages`	`FunctionReference`<`"query"`, `"public"`, `AppLinkedPagesArgs`, `AppLinkedPages`, `undefined` \| `string`>	The first linked page of each of up to `APP_STYLE_LINKED_OBJECTS` objects in one query (a map style’s linked counts and events).
`mapLayerObjects`	`FunctionReference`<`"query"`, `"public"`, `AppMapLayerObjectsArgs`, `AppMapLayerObjects`, `undefined` \| `string`>	One objects layer of a saved map and every object of its scope the caller may read, optionally within a box, in one query (one snapshot): the Map Rendering API’s read.
`recordExport`	`FunctionReference`<`"mutation"`, `"public"`, `AppExportArgs`, { `id`: `string` }, `undefined` \| `string`>	Record one export before it is downloaded: a map (a PNG capture or a GeoJSON download: its map, layers and the watermark burned into it) or objects (their collection, format, count and scope); the audit entry holds the exporter and the time. A refused record aborts the export.
`exports`	`FunctionReference`<`"query"`, `"public"`, { `cursor`: `null` \| `string` }, { `page`: `AppExport`[] ; `cursor`: `null` \| `string` }, `undefined` \| `string`>	The export audit, newest first, `MAP_EXPORTS_PAGE` per page (administrators only).
`catalog`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppCatalog`, `undefined` \| `string`>	-
`browse`	`FunctionReference`<`"query"`, `"public"`, `AppBrowseArgs`, `AppPage`, `undefined` \| `string`>	-
`requestObserve`	`FunctionReference`<`"query"`, `"public"`, { `request_id`: `string` ; `binding?`: `Readonly`<{ `function`: `string` ; `contract_digest`: `string` }> }, { `revision`: `string` }, `undefined` \| `string`>	-
`questionAccess`	`FunctionReference`<`"query"`, `"public"`, { `expression_json?`: `string` }, `null`, `undefined` \| `string`>	The one statement a workspace view of a virtual table means, checked against the caller’s catalog as a native read of the view is: its rows as a table shows them, or the summary a chart draws. Run the rows with `questionAsk`; `virtualSummary` plans and runs a summary itself.
`questionPlan`	`FunctionReference`<`"query"`, `"public"`, { `shape`: `"rows"` ; `view`: `AppVirtualRowsView` } \| { `shape`: `"summary"` ; `view`: `AppSummaryArgs` } \| { `shape`: `"facets"` ; `view`: `Omit`<`AppSummaryArgs`, `"groupBy"`> & { `histogram?`: `string` } }, `AppVirtualPlan`, `undefined` \| `string`>	-
`questionSummary`	`FunctionReference`<`"action"`, `"public"`, `AppSummaryArgs`, `AnswerResponse`<`AppVirtualSummary`>, `undefined` \| `string`>	Value counts and histograms of a virtual table’s declared dimensions with explicit read consistency; see AppVirtualFacets. `histogram` names the date dimension to bucket, as for `facets`.
`questionFacets`	`FunctionReference`<`"action"`, `"public"`, `Omit`<`AppSummaryArgs`, `"groupBy"`> & { `histogram?`: `string` ; `read`: `AnswerReadRequirement` }, `AnswerResponse`<`AppVirtualFacets`>, `undefined` \| `string`>	-
`questionAsk`	`FunctionReference`<`"action"`, `"public"`, { `program_json`: `string` ; `read?`: `AnswerReadRequirement` ; `request_id`: `string` ; `read_contract?`: `Value` ; `max_rows?`: `number` ; `max_bytes?`: `number` }, `AnswerResponse`<`RequestState`<`QuestionOutputTypes`>>, `undefined` \| `string`>	Start an expiring request; keep request_id unchanged across retries.
`requestStatus`	`FunctionReference`<`"action"`, `"public"`, { `request_id`: `string` }, `AnswerResponse`<`RequestState`<`QuestionOutputTypes`>>, `undefined` \| `string`>	-
`answerPage`	`FunctionReference`<`"action"`, `"public"`, { `answer_id`: `string` ; `request_id`: `string` ; `output`: `string` ; `cursor?`: `string` ; `page_size?`: `number` }, `AnswerResponse`<`AnswerPage`<`Record`<`string`, `Value`>>>, `undefined` \| `string`>	-
`answerFacets`	`FunctionReference`<`"action"`, `"public"`, { `answer_id`: `string` ; `request_id`: `string` ; `output`: `string` ; `fields`: `AnswerFacetSpecification`<`Record`<`string`, `Value`>>[] }, `AnswerResponse`<`AnswerFacets`<`Record`<`string`, `Value`>>>, `undefined` \| `string`>	Complete distributions of the retained answer, without rereading sources.
`requestClose`	`FunctionReference`<`"action"`, `"public"`, { `request_id`: `string` }, `AnswerResponse`<`RequestControl`<`Record`<`string`, `Value`>>>, `undefined` \| `string`>	-
`questionExplain`	`FunctionReference`<`"action"`, `"public"`, { `program_json`: `string` ; `read?`: `AnswerReadRequirement` ; `max_rows?`: `number` ; `max_bytes?`: `number` }, `AnswerResponse`<`AnswerExplanation`>, `undefined` \| `string`>	Describe the admitted source plan without running its data statement.
`get`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id`: `string` ; `fields?`: `string`[] }, `null` \| `AppObject`, `undefined` \| `string`>	-
`getMany`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `ids`: `string`[] }, `AppPointRead`[], `undefined` \| `string`>	Up to `appPointReadLimit(collection)` objects of one collection, each answered on its own (see AppPointRead), in the order asked.
`linkRecords`	`FunctionReference`<`"query"`, `"public"`, `AppLinkRecordsArgs`, `AppRelatedPage`, `undefined` \| `string`>	-
`activity`	`FunctionReference`<`"query"`, `"public"`, { `cursor`: `null` \| `string` ; `needs_attention`: `boolean` ; `target?`: { `view`: `string` ; `id`: `string` } ; `resource?`: `AppResourceRef` }, `AppActivityPage`, `undefined` \| `string`>	-
`explainResource`	`FunctionReference`<`"query"`, `"public"`, `AppExplainArgs`, `AppResourceExplanation`, `undefined` \| `string`>	-
`inspectResources`	`FunctionReference`<`"query"`, `"public"`, { `refs`: `string`[] ; `context?`: `AppInspectionContext` }, { `context`: `AppInspectionContext` ; `resources`: `AppResourceSummary`[] }, `undefined` \| `string`>	-
`inspectResource`	`FunctionReference`<`"query"`, `"public"`, `AppInspectionArgs`, `AppResourceInspection`, `undefined` \| `string`>	-
`resourceLineage`	`FunctionReference`<`"query"`, `"public"`, `AppLineageArgs`, `AppResourceLineage`, `undefined` \| `string`>	-
`resourceHealth`	`FunctionReference`<`"query"`, `"public"`, `AppHealthArgs`, { `resource`: `AppResourceSummary` ; `context`: `AppInspectionContext` ; `assessments`: `AppHealthAssessment`[] ; `sources`: `null` \| { `items`: `AppDependencySource`[] ; `is_complete`: `boolean` } }, `undefined` \| `string`>	-
`dependencyStatus`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `id?`: `string` }, `AppDependencyStatus`, `undefined` \| `string`>	-
`sourceRuns`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `source?`: `string` ; `after_sequence?`: `bigint` ; `through_sequence?`: `bigint` ; `limit?`: `number` }, `AppSourceRunsPage`, `undefined` \| `string`>	A synced collection’s sources and their syncs; `source` also returns that source’s history.
`sourceControls`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `source`: `string` }, { `refresh`: `boolean` ; `check`: `boolean` }, `undefined` \| `string`>	Per-source, per-action permission; mutations recheck the same policy.
`sourceRequestStatus`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `source`: `string` ; `request_id`: `string` }, `SourceRequestStatus`, `undefined` \| `string`>	Observe the current caller’s retained request under source read authority.
`requestSourceRefresh`	`FunctionReference`<`"mutation"`, `"public"`, { `collection`: `string` ; `source`: `string` ; `request_id`: `string` ; `recover`: `boolean` }, `AppSourceRefreshReceipt`, `undefined` \| `string`>	Refresh one source now, when `sourceControl` allows the caller.
`connectionCheckHistory`	`FunctionReference`<`"query"`, `"public"`, { `collection`: `string` ; `source`: `string` }, `ConnectionCheckHistoryEntry`[], `undefined` \| `string`>	Record a connection check for the caller, when `sourceControl` allows them; execute it with runConnectionCheck.
`completeConnectionCheck`	`FunctionReference`<`"mutation"`, `"public"`, { `collection`: `string` ; `source`: `string` ; `request`: `string` }, `CheckReceipt`, `undefined` \| `string`>	-
`requestConnectionCheck`	`FunctionReference`<`"mutation"`, `"public"`, { `collection`: `string` ; `source`: `string` }, `AppConnectionCheckRequest`, `undefined` \| `string`>	-
`accessRequests`	`FunctionReference`<`"query"`, `"public"`, `Record`<`string`, `never`>, `AppAccessRequestPage`, `undefined` \| `string`>	The access requests this caller may see; writes go through sendAccessRequestAction.

featureApi

▸ featureApi<Contract>(feature, names): Contract Public function references for one exposed feature, built exactly like applicationApi. The caller declares the feature module’s contract; this resolves module:name and grants no authority of its own.

Type parameters

Name	Type
`Contract`	extends `Record`<`string`, `FunctionReference`<`FunctionType`, `"public"`, `any`, `any`>>

Parameters

Name	Type
`feature`	`AppFeature`
`names`	readonly keyof `Contract` & `string`[]

Returns

Contract

parseInspectionSelection

▸ parseInspectionSelection(encoded?): AppInspectionSelection | null One bounded wire vocabulary for links from evidence, alerts and graph views. A parsed selection grants no authority; the ordinary reader checks access.

Parameters

Name	Type
`encoded?`	`string`

Returns

AppInspectionSelection | null

inspectionLink

▸ inspectionLink(ref, selection?, context?): string

Parameters

Name	Type
`ref`	`AppResourceRef` \| { `ref`: `AppResourceRef` ; `id`: `string` }
`selection?`	`AppInspectionSelection`
`context?`	`AppInspectionContext`

Returns

string

inspect

▸ inspect(resource, options?): Extract<InspectionQuery, { kind: "inspect" }>

Parameters

Name	Type
`resource`	`Resource`
`options`	`Omit`<`AppInspectionArgs`, `"ref"`>

Returns

Extract<InspectionQuery, { kind: "inspect" }>

lineage

▸ lineage(target, options?): Extract<InspectionQuery, { kind: "lineage" }>

Parameters

Name	Type
`target`	`Resource` \| `AppResourceField`
`options`	`Omit`<`AppLineageArgs`, `"ref"`>

Returns

Extract<InspectionQuery, { kind: "lineage" }>

health

▸ health(resource, options?): Extract<InspectionQuery, { kind: "health" }>

Parameters

Name	Type
`resource`	`Resource`
`options`	`Omit`<`AppHealthArgs`, `"ref"`>

Returns

Extract<InspectionQuery, { kind: "health" }>

explain

▸ explain(target): Object

Parameters

Name	Type
`target`	`AppResourceRow` \| `AppResourceCell`

Returns

Object

Name	Type
`kind`	`"explain"`
`args`	`AppInspectionArgs` & { `explanation`: `AppNativeExplainSelection` }

▸ explain(target): Object

Parameters

Name	Type
`target`	`AppResourceField`

Returns

Object

Name	Type
`kind`	`"explain"`
`args`	`AppExplainArgs`

▸ explain(target, selection): Object

Parameters

Name	Type
`target`	`Resource`
`selection`	`AppExplainSelection`

Returns

Object

Name	Type
`kind`	`"explain"`
`args`	`AppExplainArgs`

▸ explain(target, selection): Object

Parameters

Name	Type
`target`	`Resource`
`selection`	`AppNativeExplainSelection`

Returns

Object

Name	Type
`kind`	`"explain"`
`args`	`AppInspectionArgs` & { `explanation`: `AppNativeExplainSelection` }

appLineageNodeId

▸ appLineageNodeId(ref): string The stable key of a reported node, as the host’s graph names it: collection:<name>, producer:<name>, operation:<component>/<operation> (an empty component for the root program) or capability:<id>.

Parameters

Name	Type
`ref`	`AppLineageRef`

Returns

string

validateLineage

▸ validateLineage(value, collections): AppLineage Admit a saved lineage against the caller’s authorized collections, or refuse it with one Invalid lineage: ... message. A subject, or a focused collection, the caller cannot see is refused like a malformed one, so a saved lineage never names a collection it could not show.

Parameters

Name	Type
`value`	`unknown`
`collections`	readonly `Pick`<`AppCollection`, `"name"`>[]

Returns

AppLineage

appRenderBoxError

▸ appRenderBoxError(box): string | null The sentence refusing a box, or null.

Parameters

Name	Type
`box`	`AppRenderBox`

Returns

string | null

appRenderClauses

▸ appRenderClauses(field, box): AppWithin[] The spatial clauses of a box on one field: one, or the two halves of a box crossing the antimeridian.

Parameters

Name	Type
`field`	`string`
`box`	`AppRenderBox`

appCanonicalGlStyle

▸ appCanonicalGlStyle(text): AppCanonicalGlStyle text as the canonical GL style fragment of an overlay, or why it is refused: a JSON object of exactly sources and layers (a MapLibre or Mapbox GL style’s members of those names), at most APP_OVERLAY_STYLE_BYTES bytes.

sources: 1 to 8 by id, vector or raster, naming their tiles (1 to 4 URL templates, each by appMapUrlError; a TileJSON url is refused, since the tiles it names could not be checked) with optional minzoom, maxzoom, tileSize (raster 256 or 512), scheme, bounds and attribution. A geojson source is refused: the map would fetch it whole, past the overlay bounds; a GeoJSON URL is its own overlay (geojsonUrl), fetched and admitted within APP_OVERLAY_BYTES and APP_OVERLAY_FEATURES.
layers: 1 to 32, each fill, line, circle, heatmap, raster or fill-extrusion of a declared source (source-layer for a vector one), with optional minzoom, maxzoom, filter, layout and paint. Symbol and background layers are refused: the fragment declares no glyphs or sprites, and a background would hide every other layer.

Canonical form is the compact JSON text of the parsed value.

Parameters

Name	Type
`text`	`string`

Returns

AppCanonicalGlStyle

appOverlayLayerError

▸ appOverlayLayerError(value): string | null Why value is not an admissible overlay layer, or null: one source (see AppOverlaySource; uploaded GeoJSON and GL styles in canonical form, every URL by appMapUrlError) and an optional style checked as a layer without objects (appLayerStyleError(style, null)). A style applies to GeoJSON and vector tile overlays; a raster or GL style overlay takes none.

Parameters

Name	Type
`value`	`unknown`

Returns

string | null

appMapSettingsError

▸ appMapSettingsError(value): string | null Why value is not admissible deployment map settings, or null. Bounds: APP_MAP_SETTINGS; a default viewport’s centre is a WGS84 [longitude, latitude] and its zoom 0 to 24; custom basemaps are keyless options (appBasemapOptionError), at most APP_BASEMAP_OPTIONS. Whether the default basemap names an option is checked by the application, which knows the program’s options.

Parameters

Name	Type
`value`	`unknown`

Returns

string | null

appEffectiveWatermark

▸ appEffectiveWatermark(rules, declared, memberOf, fallback): string | null The watermark a member sees: the text of the first rule whose group the member is in, else the program’s watermark for them, else null. A rule naming a group the program no longer declares never matches.

Parameters

Name	Type
`rules`	`AppMapSettings`[`"watermarks"`]
`declared`	`ReadonlySet`<`string`>
`memberOf`	`ReadonlySet`<`string`>
`fallback`	`string` \| `null`

Returns

string | null

appExportError

▸ appExportError(value): string | null Why value is not admissible recordExport arguments, or null. The object count’s bound is recordExport’s own refusal (export_rows).

Parameters

Name	Type
`value`	`unknown`

Returns

string | null

appAggregateExprSums

▸ appAggregateExprSums(expr): string[] The measures an expression sums, each once, in first-use order.

Parameters

Name	Type
`expr`	`AppAggregateExpr`

Returns

string[]

appAggregateExprError

▸ appAggregateExprError(x, measures): string | null Why x is not an admissible AppAggregateExpr over measures, or null. Checks shape, operators, declared measures, decimal constants and the APP_AGGREGATE_EXPR bounds before anything is walked further.

Parameters

Name	Type
`x`	`unknown`
`measures`	readonly `string`[]

Returns

string | null

appMediaIconType

▸ appMediaIconType(contentType): boolean Whether a stored file’s content type is one a map draws as an icon: its media type, before any parameter and without regard to case, is one of APP_MEDIA_ICON_TYPES. A parameter is how an application tags an upload with the flow that issued it (image/png; trailer=T7).

Parameters

Name	Type
`contentType`	`unknown`

Returns

boolean

appMediaPath

▸ appMediaPath(ref): string The route path of one object’s media property (APP_MEDIA_ROUTE).

Parameters

Name	Type
`ref`	`Object`
`ref.collection`	`string`
`ref.id`	`string`
`ref.property`	`string`

Returns

string

appMediaImageryType

▸ appMediaImageryType(contentType): boolean Whether a stored file’s content type is an imagery archive’s: its media type, before any parameter and without regard to case, is APP_MEDIA_IMAGERY_TYPE.

Parameters

Name	Type
`contentType`	`unknown`

Returns

boolean

appImageryFootprint

▸ appImageryFootprint(style, collection): string | null The footprint property an imagery style draws over: the declared footprint of its imagery property, or null for another style or an undeclared property.

Parameters

Name	Type
`style`	`AppLayerStyle` \| `undefined`
`collection`	`AppCollection` \| `null`

Returns

string | null

appLayerStyleValues

▸ appLayerStyleValues(style): AppStyleValue[] Every value a style reads, in a fixed order (colour, size, icon, label, rotation’s property, radius’s property), duplicates included. A media icon’s image is read through the media route, not as a value.

Parameters

Name	Type
`style`	`AppLayerStyle`

Returns

AppStyleValue[]

appEventCollections

▸ appEventCollections(collections): string[] The catalog’s event collections (those declaring event), which linked events values may reach.

Parameters

Name	Type
`collections`	readonly `Pick`<`AppCollection`, `"name"` \| `"event"`>[]

Returns

string[]

appLayerStyleError

▸ appLayerStyleError(style, collection, functions?, events?): string | null Why style is not an admissible layer style for a layer of collection (null for a layer without objects: an overlay’s features), or null. A function value must be among functions, the registered map values (AppCatalog.maps.values); none are admitted when it is omitted. A linked events value’s relation must reach one of events, the catalog’s event collections (appEventCollections); none do when omitted.

Parameters

Name	Type	Default value
`style`	`unknown`	`undefined`
`collection`	`AppCollection` \| `null`	`undefined`
`functions`	`AppStyleFunctions`	`[]`
`events`	readonly `string`[]	`[]`

Returns

string | null

appMapSharingError

▸ appMapSharingError(value, people): string | null Why value is not admissible AppMapSharing, or null. people: whether the application declares people (an editor list needs them). Whether each named id is a person the caller may read is the application’s check.

Parameters

Name	Type
`value`	`unknown`
`people`	`boolean`

Returns

string | null

appMapSharingEqual

▸ appMapSharingEqual(a, b): boolean Whether two admitted sharings are the same (editor order aside).

Parameters

Name	Type
`a`	`AppMapSharing`
`b`	`AppMapSharing`

Returns

boolean

appTrackPresentationError

▸ appTrackPresentationError(value): string | null Why a track presentation is not one, or null.

Parameters

Name	Type
`value`	`unknown`

Returns

string | null

appMapFields

▸ appMapFields(collection): AppMapField[] The fields a map can draw a collection by: declared geometry fields, then declared series properties, each in name order. Empty when the collection is not mappable. A declaration the catalog refuses is not listed.

Parameters

Name	Type
`collection`	`AppCollection`

Returns

AppMapField[]

appDefaultMapField

▸ appDefaultMapField(collection): string | null The field a new objects layer of collection draws: its declared default map field, else its first mappable field; null when it has none.

Parameters

Name	Type
`collection`	`AppCollection`

appReferenceCollection

▸ appReferenceCollection<T>(collections, validator, lookup?): T | undefined

Type parameters

Name	Type
`T`	extends `Pick`<`AppCollection`, `"name"` \| `"kind"` \| `"identity_table"`>

Parameters

Name	Type
`collections`	readonly `T`[]
`validator`	`ValidatorJSON`
`lookup?`	`string`

Returns

T | undefined

appIsRegionalFormat

▸ appIsRegionalFormat(tag): boolean Whether tag is a regional format a member may save in preferences.locale: en, or en- followed by an upper-case ISO 3166 region (en-GB) or a three-digit UN M.49 area (en-150). Interface copy is English, so the format’s language is English too: dates and numbers never mix another language’s month names into the interface.

Parameters

Name	Type
`tag`	`string`

Returns

boolean

appIsTimeZone

▸ appIsTimeZone(zone): boolean Whether zone is a time zone a member may save in preferences.timeZone: UTC, or an IANA name such as Europe/Paris, America/Argentina/Buenos_Aires or Etc/GMT+5, at most 64 characters. The zone applies to recorded instants only. Calendar dates, UTC day buckets, relative date filters and chart axes are not shifted by it.

Parameters

Name	Type
`zone`	`string`

Returns

boolean

objectChunks

▸ objectChunks(collection, ids): string[][] ids in calls of at most appPointReadLimit(collection), order kept.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"read_cost"`>
`ids`	readonly `string`[]

Returns

string[][]

labelCost

▸ labelCost(collection): number Subjects one object of collection costs in a labels call.

Parameters

Name	Type
`collection`	`Pick`<`AppCollection`, `"read_cost"`> \| `undefined`

Returns

number

labelChunks

▸ labelChunks<T>(objects, collections): T[][] objects in labels calls whose summed cost stays within the budget and whose length stays within POINT_READ_OBJECTS, order kept. collections gives each collection’s read cost; a collection it does not list is charged as unbounded.

Type parameters

Name	Type
`T`	extends `Object`

Parameters

Name	Type
`objects`	readonly `T`[]
`collections`	readonly `Pick`<`AppCollection`, `"name"` \| `"read_cost"`>[] \| `undefined`

Returns

T[][]

relationIdentity

▸ relationIdentity(types, sourceCollection, sourceId, relationName, targetId): string Canonical identity of a presented relation membership. Inverses agree only when both select the same pair of collections; projection aliases that change the presented set retain distinct identities.

Parameters

Name	Type
`types`	readonly `AppCollection`[]
`sourceCollection`	`string`
`sourceId`	`string`
`relationName`	`string`
`targetId`	`string`

Returns

string

resourceInventory

▸ resourceInventory(catalog): Map<AppResourceRef, AppResourceSummary>

Parameters

Name	Type
`catalog`	`AppCatalog`

Returns

Map<AppResourceRef, AppResourceSummary>

expectationOutcome

▸ expectationOutcome(observation, key): AppHealthOutcome Native verdict projection shared by assessments and temporal condition owners.

Parameters

Name	Type
`observation`	`Pick`<`AppSourceHealthObservation`, `"quality"`>
`key`	`string`

Returns

AppHealthOutcome

seriesMeasurePoints

▸ seriesMeasurePoints(buckets): number The max_points of a seriesMeasure request that the server splits into exactly buckets equal time buckets when it downsamples: it makes floor((max_points - 1) / 3) buckets, each keeping its minimum, its maximum and its first report without the measure, plus the window’s newest report.

Parameters

Name	Type
`buckets`	`number`

Returns

number

appSeriesMillis

▸ appSeriesMillis(micros): string Exact decimal epoch milliseconds of a signed microsecond instant or duration: whole milliseconds as an integer, otherwise with the fraction’s significant digits ("1700000000000.25").

Parameters

Name	Type
`micros`	`bigint`

Returns

string

appExpressionLeaves

▸ appExpressionLeaves(node): AppExpressionLeaf[] The leaves of an expression tree, or why it is not one. At most 32 nodes and depth 8, as the native evaluator bounds them.

Parameters

Name	Type
`node`	`unknown`

Returns

AppExpressionLeaf[]

appExpressionMeasures

▸ appExpressionMeasures(node): string[] The distinct measures an expression tree reads.

Parameters

Name	Type
`node`	`unknown`

Returns

string[]

appExpressionFields

▸ appExpressionFields(collection): AppExpressionField[] Component-backed track expression properties, in name order. Native temporal properties are schema-owned definitions built with defineView(…).derive. Throws when a declaration is not one: the name is not an admitted property and declares no series or format, of names a series property of the same collection whose declared measures include every measure the tree reads, and max_gap_ms is a positive whole number of milliseconds. The native evaluator checks the tree itself when it first runs.

Parameters

Name	Type
`collection`	`SeriesDeclarations`

Returns

AppExpressionField[]

appSeriesFields

▸ appSeriesFields(collection): AppSeriesField[] The declared series properties of a collection, in property name order. Throws when a declaration does not match the admitted validator: the derived name must not be an admitted property, it declares no format, and series.id names an admitted string property. The application refuses such a declaration when it builds its catalog.

Parameters

Name	Type
`collection`	`SeriesDeclarations`

Returns

AppSeriesField[]

appSeriesTime

▸ appSeriesTime(value): bigint | null A decimal int64 epoch-millisecond string as a bigint, or null when it is not one (no sign, no exponent, at most 2^63 - 1).

Parameters

Name	Type
`value`	`unknown`

Returns

bigint | null

appStrongerRole

▸ appStrongerRole(a, b): AppSavedRole The stronger of two roles.

Parameters

Name	Type
`a`	`AppSavedRole`
`b`	`AppSavedRole`

Returns

AppSavedRole

appShareGrantsError

▸ appShareGrantsError(people, self): string | null Why people is not an admissible grant list for a caller whose own person is self, or null: at most MAX_SHARE_PEOPLE grants, each a non-empty person id named once, never the caller’s own person, each a viewer or an editor. Whether each id is a person the caller may read is the application’s check. The workspace runs this before it calls share, which runs it again.

Parameters

Name	Type
`people`	`unknown`
`self`	`string` \| `null`

Returns

string | null

appTimeBucketStart

▸ appTimeBucketStart(ms, unit): number Start of a UTC bucket in exact milliseconds, flooring before the epoch too.

Parameters

Name	Type
`ms`	`number`
`unit`	`AppTimeUnit`

Returns

number

appTimeBucketEnd

▸ appTimeBucketEnd(start, unit): number Exclusive end of the UTC bucket starting at start.

Parameters

Name	Type
`start`	`number`
`unit`	`AppTimeUnit`

Returns

number

appTimeRefines

▸ appTimeRefines(stored, requested): boolean Whether each stored bucket fits wholly inside one requested bucket.

Parameters

Name	Type
`stored`	`AppTimeUnit`
`requested`	`AppTimeUnit`

Returns

boolean

appFilterMatches

▸ appFilterMatches(row, filters): boolean Whether one already-read object matches filters, all of them. This is for a point read, where no bounded index range can carry the predicate to the native reader: a Search Around hop that follows a reference to one object of a view. The predicate is appFilterGroup’s own expression tree — the same operator meanings, ranges and presence tests the native reader evaluates — and this supplies only its primitive comparisons, in the inherited Bijection value order (compareValues): the order the native reader compares by, with a missing property below null, int64 below float64, -0 below 0 and strings by their UTF-8 bytes. The object must have been read in full by the same query, so the read set already holds every value the predicate depends on.

Parameters

Name	Type
`row`	`Record`<`string`, `Value` \| `undefined`>
`filters`	`AppFilter`[]

Returns

boolean

​Classes

​References

​SourceStatus

​Type Aliases

​ArgumentIssueCode

​ArgumentValueIssue

​Type declaration

​AppBoardField

​Type declaration

​AppBoundRefusal

​Type declaration

​AppInvalidRequest

​Type declaration

​AppCadence

​AppComments

​Type declaration

​AppCommentsPlan

​Type declaration

​AppCanonicalMentions

​AppCursor

​AppPageRestart

​Type declaration

​DataReleaseDefinition

​Type declaration

​DataReleaseSource

​Type declaration

​DataReleaseContainer

​DataReleaseReceipt

​Type declaration

​ReleaseAccessSimulation

​Type declaration

​ResourceRef

​ResourceKind

​DiscoverySummary

​Type declaration

​DiscoverArgs

​Type declaration

​DiscoveryPage

​Type declaration

​DiscoveredFunction

​Type declaration

​OperationCompanion

​ResourceSummary

​Type parameters

​SeriesReader

​Type declaration

​DiscoveryResource

​DiscoveryDescription

​ArgumentChoicesArgs

​Type declaration

​ArgumentChoicesPage

​Type declaration

​AppObjectFile

​Type declaration

​AppGeometryType

​AppGeometryProfile

​AppGeometrySize

​AppGeometryDeclaration

​Type declaration

​AppSpatialField

​AppRegion

​AppRegionRefusal

​Type declaration

​AppSpatialMode

​AppWithin

​Type declaration

​AppNearest

​Type declaration

​AppCellGrouping

​Type declaration

​AppRegionKind

​AppSpatialIndexInfo

​Type declaration

​AppMapView

​Type declaration

​AppMapAggregate

​AppCellSystem

​AppPointSource

​AppGeometrySource

​AppGeometryField

Classes

References

SourceStatus

Type Aliases

ArgumentIssueCode

ArgumentValueIssue

Type declaration

AppBoardField

Type declaration

AppBoundRefusal

Type declaration

AppInvalidRequest

Type declaration

AppCadence

AppComments

Type declaration

AppCommentsPlan

Type declaration

AppCanonicalMentions

AppCursor

AppPageRestart

Type declaration

DataReleaseDefinition

Type declaration

DataReleaseSource

Type declaration

DataReleaseContainer

DataReleaseReceipt

Type declaration

ReleaseAccessSimulation

Type declaration

ResourceRef

ResourceKind

DiscoverySummary

Type declaration

DiscoverArgs

Type declaration

DiscoveryPage

Type declaration

DiscoveredFunction

Type declaration

OperationCompanion

ResourceSummary

Type parameters

SeriesReader

Type declaration

DiscoveryResource

DiscoveryDescription

ArgumentChoicesArgs

Type declaration

ArgumentChoicesPage

Type declaration

AppObjectFile

Type declaration

AppGeometryType

AppGeometryProfile

AppGeometrySize

AppGeometryDeclaration

Type declaration

AppSpatialField

AppRegion

AppRegionRefusal

Type declaration

AppSpatialMode

AppWithin

Type declaration

AppNearest

Type declaration

AppCellGrouping

Type declaration

AppRegionKind

AppSpatialIndexInfo

Type declaration

AppMapView

Type declaration

AppMapAggregate

AppCellSystem

AppPointSource

AppGeometrySource

AppGeometryField