@registrystack/client 0.29.0 → 0.30.0

package/README.md

@@ -1,7 +1,7 @@
 # @registrystack/client
 
-One versioned Node.js package for the Discovery, Evidence, Relay, and Base
-Registry Engine client APIs in Registry Stack.
+One versioned Node.js package for the Discovery, Evidence, Relay, Base Registry
+Engine, and Casework client APIs in Registry Stack.
 
 ## Install
 
@@ -11,17 +11,20 @@ npm install "@registrystack/client@<version>"
 
 Requires Node.js 22.12 or newer. Supported targets are macOS arm64, Linux
 arm64 with glibc, and Linux x64 with glibc; installing the package pulls in
-one platform-specific optional dependency containing all four native
+one platform-specific optional dependency containing all five native
 bindings.
 
 ## Usage
 
 ```js
-const { discovery, evidence, relay, breg } = require('@registrystack/client');
+const { discovery, evidence, relay, breg, casework } = require('@registrystack/client');
 
 const registry = new breg.BaseRegistryClient({
   baseUrl: 'https://registry.example.invalid/',
 });
+const work = new casework.CaseworkClient({
+  baseUrl: 'https://casework.example.invalid/',
+});
 ```
 
 ## Products
@@ -32,6 +35,8 @@ const registry = new breg.BaseRegistryClient({
   assertions.
 - `relay`: Registry Relay, scoped read-only APIs over existing sources.
 - `breg`: Base Registry Engine, records, contracts, writes, and lifecycle.
+- `casework`: Registry Casework, staff inbox, claims, drafts, decisions,
+  recovery, history, holdings, and directory bootstrap.
 
 Each product remains in its own namespace because its routing,
 authentication, errors, and verification rules are different.
@@ -63,7 +68,8 @@ consumer does not need it.
 ## Base Registry Engine notes
 
 `breg.BaseRegistryClient.registryContract()` returns caller-filtered
-`operations` with typed field, request, and list-query descriptors; those
+`operations` with typed field, readable request field, request, and list-query
+descriptors; those
 descriptions grant no authority, so select the opaque create, patch, and
 lifecycle authorities from that same contract before executing a mutation.
 Methods ending in `Json` keep values exact across the Node number boundary:
@@ -81,6 +87,21 @@ standalone client packages remain available for earlier versions, but the
 release process does not publish new standalone versions once this package
 is active.
 
+The `casework` namespace is part of the unified package beginning with
+Registry Stack v0.30.0.
+
+## Casework notes
+
+The Casework module is for a trusted server host. Each call takes that request's
+bearer token and selected Casework profile; source-reading calls also take the
+selected source profile. The client does not retain them. Browsers should send
+only the host's session cookie. Claim, release, and decide consume the
+caller-filtered action returned on the item, including its exact route and
+`ifMatch` revision. Mutations require a caller-controlled idempotency key and
+are never retried automatically. After a lost response, use
+`recoverDecisionByKey` with the original key so recovery does not depend on the
+attempt identifier being received.
+
 ## Documentation
 
 - [Client API reference](https://docs.registrystack.org/reference/client-api/)

package/breg/client.d.ts

@@ -1,5 +1,8 @@
 export type JsonScalar = string | number | boolean | null
 export type JsonValue = JsonScalar | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }
+/** Structured mutation inputs reject integer-valued numbers outside
+ * `Number.isSafeInteger`. Use the corresponding `...Json` method for exact
+ * wider integer values. */
 export type JsonObject = { readonly [key: string]: JsonValue }
 /** An integer that satisfies `Number.isSafeInteger` and the option's documented bounds. */
 export type SafeInteger = number
@@ -40,17 +43,46 @@ export interface BaseRegistryClientConfig {
 
 export type RecordFormat = 'json' | 'json-ld'
 
-export interface RecordOptions {
+export interface RecordProjectionOptions {
   select?: ReadonlyArray<string> | null
   accessProfile?: string | null
   format?: RecordFormat | null
 }
 
-export interface ListOptions extends RecordOptions {
+export interface RecordOptions extends RecordProjectionOptions {
+  requestHistoryAfterProposalVersion?: SafeInteger | null
+}
+
+export interface ListOptions extends RecordProjectionOptions {
+  top?: SafeInteger | null
+  filter?: string | null
+  orderby?: string | null
+  count?: boolean | null
+  bbox?: BoundingBox | null
+}
+
+export interface CollectionOptions extends RecordProjectionOptions {
+  top?: SafeInteger | null
+  filter?: string | null
+  orderby?: string | null
+  count?: boolean | null
+}
+export interface AsOfListOptions extends CollectionOptions { asOf: string }
+export interface SnapshotListOptions extends CollectionOptions {
+  snapshot?: string | null
+  validAt?: string | null
+}
+export type BoundingBox = readonly [west: string, south: string, east: string, north: string]
+export interface GeoJsonOptions {
+  select?: ReadonlyArray<string> | null
+  accessProfile?: string | null
+}
+export interface GeoJsonListOptions extends GeoJsonOptions {
   top?: SafeInteger | null
   filter?: string | null
   orderby?: string | null
   count?: boolean | null
+  bbox?: BoundingBox | null
 }
 
 export interface ListContinuation {
@@ -62,14 +94,92 @@ export interface ListContinuation {
   datasetIdentifier: string
   entityTypeIdentifier: string
 }
+export type CurrentListContinuation = ListContinuation
+export interface AsOfListContinuation extends ListContinuation { asOf: string }
+export interface SnapshotListContinuation extends ListContinuation {
+  snapshot: string
+  validAt?: string
+}
+export interface RelationshipListContinuation extends ListContinuation {
+  rootRecordIdentifier: string
+  pathRoute: string
+}
+export interface GeoJsonListContinuation {
+  route: string
+  skiptoken: string
+  accessProfile?: string
+}
 
 export interface RegistryRecord {
   recordIdentifier: string
   revisionIdentifier: string
   domainData: Readonly<Record<string, JsonValue>>
+  request?: BRegRequestMetadata
   readonly [member: string]: JsonValue | undefined
 }
 
+export type BRegRequestReviewStage = JsonObject & {
+  readonly id: string
+  readonly approvals: SafeInteger
+  readonly excludeSubmitter: boolean
+  readonly excludePreviousReviewers?: boolean
+}
+export type BRegRequestReviewState = JsonObject & {
+  readonly stages: ReadonlyArray<BRegRequestReviewStage>
+  readonly submittedAt: string
+  readonly pendingStage: string | null
+  readonly stageEnteredAt: string | null
+}
+export type BRegRequestReviewTiming = JsonObject & {
+  readonly firstSubmittedAt: string
+  readonly pausedMilliseconds: SafeInteger
+  readonly pauseStartedAt: string | null
+  readonly completedAt: string | null
+}
+export type BRegRequestDecision = JsonObject & {
+  readonly stageId: string
+  readonly kind: 'approve' | 'reject' | 'request_revision'
+  readonly decidedAt: string
+  readonly reasonPresent: boolean
+  readonly reason?: string
+  readonly actorReference?: string
+}
+export type BRegRequestState = 'draft' | 'submitted' | 'approved' | 'needs_changes' | 'rejected' | 'canceled' | 'applied'
+export type BRegRetainedRequestProposal = JsonObject & {
+  readonly requestEntityId: string
+  readonly requestId: string
+  readonly proposalVersion: SafeInteger
+  readonly bregState: BRegRequestState
+  readonly current: boolean
+  readonly contractFingerprint: string
+  readonly detailErased: boolean
+  readonly applicationId: string | null
+  readonly resultLinkCount: SafeInteger
+  readonly resultLinks: ReadonlyArray<JsonObject>
+  readonly effectDigest?: string
+  readonly decisions?: ReadonlyArray<BRegRequestDecision>
+}
+export type BRegRetainedRequestHistory = JsonObject & {
+  readonly proposals: ReadonlyArray<BRegRetainedRequestProposal>
+  readonly nextAfterProposalVersion: SafeInteger | null
+}
+export type BRegRequestMetadata = JsonObject & {
+  readonly bregState: BRegRequestState
+  readonly proposalVersion: SafeInteger
+  readonly effectDigest?: string | null
+  readonly proposal?: JsonObject | null
+  readonly editable: boolean
+  readonly detailErased?: true
+  readonly actions?: ReadonlyArray<JsonObject>
+  readonly application?: JsonObject | null
+  readonly history?: BRegRetainedRequestHistory
+  readonly review?: BRegRequestReviewState
+  readonly reviewTiming?: BRegRequestReviewTiming
+  readonly submitterReference?: string
+  readonly applierReference?: string
+  readonly decisions?: ReadonlyArray<BRegRequestDecision>
+}
+
 export interface RecordMetadata {
   registryIdentifier: string
   datasetIdentifier: string
@@ -106,12 +216,14 @@ export interface CompleteOutcome<T> {
   location?: string
 }
 
-export interface PageOutcome {
+export interface PageOutcome<T = RecordCollection, C = ListContinuation> {
   kind: 'complete'
-  value: RecordCollection
-  continuation?: ListContinuation
+  value: T
+  continuation?: C
   traceId: string
   etag?: string
+  snapshot?: string
+  validAt?: string
 }
 
 export interface RawOutcome {
@@ -144,23 +256,55 @@ export interface LifecycleReviewTarget {
 
 export interface LifecycleReview { targets: ReadonlyArray<LifecycleReviewTarget> }
 
-export interface LifecycleReceipt extends JsonObject {
-  id: string
-  revision: SafeInteger
-  snapshot: string
-  request: JsonObject
+export type LifecycleReceipt = JsonObject & {
+  readonly id: string
+  readonly revision: SafeInteger
+  readonly snapshot: string
+  readonly actorReference?: string
+  readonly request: BRegLifecycleReceiptRequest
+}
+
+export type BRegLifecycleReceiptRequest = JsonObject & {
+  readonly bregState: BRegRequestState
+  readonly proposalVersion: SafeInteger | null
+  readonly effectDigest: string | null
+  readonly proposal?: JsonObject | null
+  readonly application: JsonObject | null
 }
 
 /** Exact validated JSON text, serialized before conversion to JavaScript numbers.
  * Decode with a lossless JSON library if inspecting values outside the safe integer range.
  * Decimal fields remain fixed-scale JSON strings. */
-export interface JsonOutcome {
+export interface JsonOutcome<C = ListContinuation> {
   kind: 'complete'
   valueJson: string
-  continuation?: ListContinuation
+  continuation?: C
   traceId: string
   etag?: string
   location?: string
+  snapshot?: string
+  validAt?: string
+}
+
+export interface GeoJsonPoint {
+  readonly type: 'Point'
+  readonly coordinates: readonly [number, number]
+}
+export interface GeoJsonFeature {
+  readonly type: 'Feature'
+  readonly id: string
+  readonly geometry: GeoJsonPoint | null
+  readonly properties: Readonly<Record<string, JsonValue>>
+  readonly registry: { readonly revision: SafeInteger }
+}
+export interface GeoJsonFeatureCollection {
+  readonly type: 'FeatureCollection'
+  readonly features: ReadonlyArray<GeoJsonFeature>
+  readonly numberReturned: SafeInteger
+  readonly registry: {
+    readonly pageInfo: { readonly nextCursor: string | null }
+    readonly count?: SafeInteger
+  }
 }
 
 export interface BRegFieldDescriptor {
@@ -173,6 +317,20 @@ export interface BRegFieldDescriptor {
   readonly readOnly: boolean
   readonly removable: boolean
   readonly referenceTargetEntity: string | null
+  readonly codeLabels: Readonly<Record<string, string>>
+  readonly storageValidation: {
+    readonly kind: string
+    readonly pattern: string
+  } | null
+  readonly reference: {
+    readonly manualEntry: boolean
+    readonly targetEntity: string | null
+    readonly operations: ReadonlyArray<{
+      readonly operationId: string
+      readonly accessProfile: string
+      readonly labelFields: ReadonlyArray<string>
+    }>
+  } | null
 }
 export interface BRegQueryField {
   readonly id: string
@@ -192,6 +350,29 @@ export interface BRegQueryDescriptor {
   readonly maxInValues: number
   readonly pagination: { readonly parameter: string; readonly responsePath: string; readonly exclusive: boolean }
   readonly temporal: JsonObject | null
+  readonly spatialQueries?: {
+    readonly bbox: {
+      readonly geometryProperty: string
+      readonly maximumLongitudeSpanDegrees: number
+      readonly maximumLatitudeSpanDegrees: number
+      readonly coordinateReferenceSystem: string
+      readonly semantics: string
+    } | null
+  }
+}
+export interface BRegLookupSelectorFieldDescriptor {
+  readonly id: string
+  readonly apiName: string
+  readonly label: string
+  readonly schemaJson: string
+  readonly required: boolean
+}
+export interface BRegLookupSelectorDescriptor {
+  readonly id: string
+  readonly label: string
+  readonly valueOrigin: string
+  readonly fields: ReadonlyArray<BRegLookupSelectorFieldDescriptor>
+  readonly requestFields: ReadonlyArray<string>
 }
 export interface BRegOperationDescriptor {
   readonly id: string
@@ -206,9 +387,12 @@ export interface BRegOperationDescriptor {
   readonly requiredCapabilities: ReadonlyArray<string>
   readonly fields: ReadonlyArray<BRegFieldDescriptor>
   readonly readableFields: ReadonlyArray<string>
+  readonly readableRequestFields: ReadonlyArray<string>
   readonly createWritableFields: ReadonlyArray<string>
   readonly patchWritableFields: ReadonlyArray<string>
   readonly query: BRegQueryDescriptor | null
+  readonly selectors: ReadonlyArray<BRegLookupSelectorDescriptor>
+  readonly readPath: { readonly id: string; readonly label: string } | null
   readonly request: {
     readonly fieldNames: string | null
     readonly queryParameters: ReadonlyArray<string>
@@ -221,6 +405,126 @@ export interface BRegOperationDescriptor {
     readonly patchPathPrefix: string | null
     readonly patchOperations: ReadonlyArray<string>
     readonly removeSemantics: string | null
+    readonly maximumItems: SafeInteger | null
+    readonly maximumBodyBytes: SafeInteger | null
+    readonly allowCreate: boolean | null
+    readonly allowPatch: boolean | null
+  }
+}
+
+export interface BRegImmediateActionDescriptor {
+  readonly id: string
+  readonly contractFingerprint: string
+  readonly inputMode: string | null
+  readonly maximumInputStringBytes: SafeInteger | null
+  readonly inputs: ReadonlyArray<{
+    readonly id: string
+    readonly apiName: string
+    readonly fieldTypeJson: string
+    readonly required: boolean
+    readonly nullable: boolean | null
+    readonly classification: string
+  }>
+  readonly referenceInputs: ReadonlyArray<{
+    readonly input: string
+    readonly apiName: string
+    readonly targetEntity: string
+  }>
+  readonly requiredConditionKeys: ReadonlyArray<string>
+  readonly resultEffects: ReadonlyArray<{
+    readonly effect: string
+    readonly entity: string
+    readonly operation: string
+  }>
+  readonly accessProfile: string
+  readonly invokePath: string
+  readonly targetConditionsPath: string | null
+  readonly bounds: {
+    readonly maximumTargets: SafeInteger
+    readonly maximumFieldMutations: SafeInteger
+    readonly maximumSnapshotBytes: SafeInteger
+  }
+}
+
+export interface BRegActionReceipt {
+  readonly action: string
+  readonly applicationId: string
+  readonly results: Readonly<Record<string, {
+    readonly entity: string
+    readonly recordId: string
+    readonly revision: SafeInteger
+  }>>
+}
+
+export interface BRegBatchCreateItem {
+  readonly operation: 'create'
+  readonly data: JsonObject
+}
+export interface BRegBatchPatchItem {
+  readonly operation: 'patch'
+  readonly recordIdentifier: string
+  readonly etag: string
+  readonly operations: ReadonlyArray<PatchOperation | RemovePatchOperation>
+}
+export type BRegBatchItem = BRegBatchCreateItem | BRegBatchPatchItem
+export type BRegChangeContext =
+  | {
+      readonly kind: 'change'
+      readonly reasonText?: string
+      readonly sourceReferences?: ReadonlyArray<string>
+    }
+  | {
+      readonly kind: 'correction'
+      readonly reasonCode: string
+      readonly reasonText?: string
+      readonly sourceReferences?: ReadonlyArray<string>
+    }
+export interface BRegBatchInput {
+  readonly items: ReadonlyArray<BRegBatchItem>
+  readonly changeContext?: BRegChangeContext
+}
+export interface BRegBatchReceipt {
+  readonly snapshot: string
+  readonly results: ReadonlyArray<{
+    readonly operation: 'create' | 'patch'
+    readonly id: string
+    readonly revision: SafeInteger
+    readonly etag: string
+    readonly data: Readonly<Record<string, JsonValue>>
+  }>
+}
+
+export interface BRegChangeRequestCapability {
+  readonly planner: {
+    readonly kind: 'declarative' | 'rhai'
+    readonly abi: string | null
+    readonly limits: {
+      readonly maximumTargets: SafeInteger
+      readonly maximumFieldMutations: SafeInteger
+      readonly maximumSnapshotBytes: SafeInteger
+      readonly maximumSourceBytes: SafeInteger
+      readonly maximumOperations: SafeInteger
+      readonly maximumCallDepth: SafeInteger
+      readonly maximumExpressionDepth: SafeInteger
+      readonly maximumStringBytes: SafeInteger
+      readonly maximumArrayItems: SafeInteger
+      readonly maximumMapEntries: SafeInteger
+      readonly maximumModules: SafeInteger
+    } | null
+    readonly possibleWriteCount: SafeInteger | null
+    readonly possibleWriteOperations: ReadonlyArray<string>
+  }
+  readonly reviewMode: 'none' | 'staged'
+  readonly stages: ReadonlyArray<{
+    readonly id: string
+    readonly approvals: SafeInteger
+    readonly excludeSubmitter: boolean
+    readonly excludePreviousReviewers: boolean
+  }> | null
+  readonly application: {
+    readonly mode: 'manual' | 'automatic' | 'planner'
+    readonly allowedDispositions: ReadonlyArray<'apply' | 'queue'>
+    readonly queueReasons: ReadonlyArray<{ readonly code: string; readonly label: string }>
   }
 }
 
@@ -284,6 +588,29 @@ export declare class BRegPatchBinding {
   private constructor()
   private readonly __opaque: void
 }
+/** Opaque authority for one metadata-selected immediate action. */
+export declare class BRegImmediateActionBinding {
+  private constructor()
+  private readonly __opaque: void
+}
+/** Opaque target conditions obtained for one selected action and input set. */
+export declare class BRegActionTargetConditions {
+  private constructor()
+  private readonly __opaque: void
+  readonly preconditionKeys: ReadonlyArray<string>
+  readonly valueJson: string
+  readonly traceId: string
+}
+/** Opaque authority for one metadata-selected Tombstone operation. */
+export declare class BRegTombstoneBinding {
+  private constructor()
+  private readonly __opaque: void
+}
+/** Opaque authority for one metadata-selected atomic Batch operation. */
+export declare class BRegBatchBinding {
+  private constructor()
+  private readonly __opaque: void
+}
 /** Opaque lifecycle authority selected from metadata fetched by this client source. */
 export declare class BRegLifecycleAuthority {
   private constructor()
@@ -304,26 +631,61 @@ export declare class BRegLifecycleAction {
   readonly review: LifecycleReview | null
 }
 
+/** Inert bounded Create evidence. Persist these bytes with owner-only access. */
+export declare class BRegPreparedCreate {
+  private constructor()
+  private readonly __opaque: void
+  static fromBytes(bytes: Buffer): BRegPreparedCreate
+  toBytes(): Buffer
+}
+
+/** Inert bounded lifecycle evidence. Persist these bytes with owner-only access. */
+export declare class BRegPreparedLifecycle {
+  private constructor()
+  private readonly __opaque: void
+  static fromBytes(bytes: Buffer): BRegPreparedLifecycle
+  toBytes(): Buffer
+}
+
+/** Revalidated Create request. It still requires fresh metadata authority to send. */
+export declare class BRegRecoveredCreate {
+  private constructor()
+  private readonly __opaque: void
+}
+
+/** Revalidated lifecycle action. It remains inert until explicitly sent. */
+export declare class BRegRecoveredLifecycle {
+  private constructor()
+  private readonly __opaque: void
+}
+
 /** Caller-filtered metadata bound to the exact client source that fetched it. */
 export declare class BRegMetadata {
   private constructor()
   private readonly __opaque: void
   readonly operations: ReadonlyArray<BRegOperationDescriptor>
+  readonly immediateActions: ReadonlyArray<BRegImmediateActionDescriptor>
+  readonly actionsJson: string | null
   readonly registryIdentifier: string
   readonly registryVersion: string
   readonly registryRevision: string
   readonly traceId: string
   readonly etag: string | null
+  changeRequestCapability(entityIdentifier: string): BRegChangeRequestCapability | null
   selectCreate(operationIdentifier: string, expectedProfile: string): BRegCreateBinding
   selectPatch(operationIdentifier: string, expectedProfile: string): BRegPatchBinding
   selectLifecycle(entityIdentifier: string, expectedProfile: string): BRegLifecycleAuthority
   selectAttachments(entityIdentifier: string, expectedProfile: string): ReadonlyArray<BRegAttachmentSlot>
+  selectImmediateAction(actionIdentifier: string, expectedProfile: string): BRegImmediateActionBinding
+  selectTombstone(entityIdentifier: string, expectedProfile: string): BRegTombstoneBinding
+  selectBatch(entityIdentifier: string, expectedProfile: string): BRegBatchBinding
 }
 
 export interface BaseRegistryClientFailure extends Error {
   readonly kind: string
   readonly code?: string
   readonly planRefusal?: string
+  readonly refusalCode?: string
   readonly status?: number
   readonly traceId?: string
   readonly transportKind?: string
@@ -334,6 +696,7 @@ export declare class BaseRegistryClientError extends Error implements BaseRegist
   readonly kind: string
   readonly code?: string
   readonly planRefusal?: string
+  readonly refusalCode?: string
   readonly status?: number
   readonly traceId?: string
   readonly transportKind?: string
@@ -348,20 +711,62 @@ export declare class BaseRegistryClient {
   registryMetadata(accessProfile?: string | null): Promise<RawOutcome>
   registryContract(accessProfile?: string | null): Promise<BRegMetadata>
   entitySchema(entityIdentifier: string, accessProfile?: string | null): Promise<RawOutcome>
+  recordRevisions(entityRoute: string, recordIdentifier: string, accessProfile?: string | null): Promise<RawOutcome>
+  getRecordRevision(entityRoute: string, recordIdentifier: string, revision: SafeInteger, options?: RecordProjectionOptions | null): Promise<RawOutcome>
   getRecord(entityRoute: string, recordIdentifier: string, options?: RecordOptions | null): Promise<CompleteOutcome<RecordEnvelope>>
   listRecords(entityRoute: string, options?: ListOptions | null): Promise<PageOutcome>
   continueList(continuation: ListContinuation): Promise<PageOutcome>
-  lookupRecord(entityRoute: string, selector: string, values?: JsonObject | null, options?: RecordOptions | null): Promise<CompleteOutcome<RecordEnvelope>>
+  getGeoJsonRecord(entityRoute: string, recordIdentifier: string, options?: GeoJsonOptions | null): Promise<CompleteOutcome<GeoJsonFeature>>
+  listGeoJsonRecords(entityRoute: string, options?: GeoJsonListOptions | null): Promise<PageOutcome<GeoJsonFeatureCollection, GeoJsonListContinuation>>
+  continueGeoJsonList(continuation: GeoJsonListContinuation): Promise<PageOutcome<GeoJsonFeatureCollection, GeoJsonListContinuation>>
+  listCurrentRecords(entityRoute: string, options?: CollectionOptions | null): Promise<PageOutcome<RecordCollection, CurrentListContinuation>>
+  continueCurrentList(continuation: CurrentListContinuation): Promise<PageOutcome<RecordCollection, CurrentListContinuation>>
+  listRecordsAsOf(entityRoute: string, options: AsOfListOptions): Promise<PageOutcome<RecordCollection, AsOfListContinuation>>
+  continueAsOfList(continuation: AsOfListContinuation): Promise<PageOutcome<RecordCollection, AsOfListContinuation>>
+  listSnapshotRecords(entityRoute: string, options?: SnapshotListOptions | null): Promise<PageOutcome<RecordCollection, SnapshotListContinuation>>
+  continueSnapshotList(continuation: SnapshotListContinuation): Promise<PageOutcome<RecordCollection, SnapshotListContinuation>>
+  listRelationshipRecords(entityRoute: string, recordIdentifier: string, pathRoute: string, options?: CollectionOptions | null): Promise<PageOutcome<RecordCollection, RelationshipListContinuation>>
+  continueRelationshipList(continuation: RelationshipListContinuation): Promise<PageOutcome<RecordCollection, RelationshipListContinuation>>
+  lookupRecord(entityRoute: string, selector: string, values?: JsonObject | null, options?: RecordProjectionOptions | null): Promise<CompleteOutcome<RecordEnvelope>>
+  actionTargetConditions(binding: BRegImmediateActionBinding, inputs: JsonObject): Promise<BRegActionTargetConditions>
+  actionTargetConditionsJson(binding: BRegImmediateActionBinding, inputsJson: string): Promise<BRegActionTargetConditions>
+  invokeAction(binding: BRegImmediateActionBinding, inputs: JsonObject, idempotencyKey: string, conditions?: BRegActionTargetConditions | null): Promise<CompleteOutcome<BRegActionReceipt>>
+  invokeActionJson(binding: BRegImmediateActionBinding, inputsJson: string, idempotencyKey: string, conditions?: BRegActionTargetConditions | null): Promise<JsonOutcome>
   createRecord(binding: BRegCreateBinding, data: JsonObject, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
+  prepareCreate(binding: BRegCreateBinding, data: JsonObject, idempotencyKey: string, format?: RecordFormat | null): BRegPreparedCreate
+  prepareCreateJson(binding: BRegCreateBinding, dataJson: string, idempotencyKey: string, format?: RecordFormat | null): BRegPreparedCreate
+  recoverCreate(binding: BRegCreateBinding, prepared: BRegPreparedCreate): BRegRecoveredCreate
+  executeRecoveredCreate(binding: BRegCreateBinding, recovered: BRegRecoveredCreate): Promise<CompleteOutcome<RecordEnvelope>>
+  executeRecoveredCreateJson(binding: BRegCreateBinding, recovered: BRegRecoveredCreate): Promise<JsonOutcome>
   patchRecord(binding: BRegPatchBinding, recordIdentifier: string, etag: string, operations: ReadonlyArray<PatchOperation | RemovePatchOperation>, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
+  batchRecords(binding: BRegBatchBinding, request: BRegBatchInput, idempotencyKey: string): Promise<CompleteOutcome<BRegBatchReceipt>>
+  batchRecordsJson(binding: BRegBatchBinding, requestJson: string, idempotencyKey: string): Promise<JsonOutcome>
+  tombstoneRecord(binding: BRegTombstoneBinding, recordIdentifier: string, etag: string, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
+  tombstoneRecordJson(binding: BRegTombstoneBinding, recordIdentifier: string, etag: string, idempotencyKey: string, format?: RecordFormat | null): Promise<JsonOutcome>
   lifecycleActions(authority: BRegLifecycleAuthority, record: RecordEnvelope, format?: RecordFormat | null): ReadonlyArray<BRegLifecycleAction>
+  prepareLifecycleAction(authority: BRegLifecycleAuthority, record: RecordEnvelope, action: BRegLifecycleAction, idempotencyKey: string, format?: RecordFormat | null): BRegPreparedLifecycle
+  prepareLifecycleActionJson(authority: BRegLifecycleAuthority, recordJson: string, action: BRegLifecycleAction, idempotencyKey: string, format?: RecordFormat | null): BRegPreparedLifecycle
+  recoverLifecycleAction(authority: BRegLifecycleAuthority, prepared: BRegPreparedLifecycle): BRegRecoveredLifecycle
+  executeRecoveredLifecycleAction(recovered: BRegRecoveredLifecycle): Promise<CompleteOutcome<LifecycleReceipt>>
+  executeRecoveredLifecycleActionJson(recovered: BRegRecoveredLifecycle): Promise<JsonOutcome>
   uploadAttachment(slot: BRegAttachmentSlot, recordIdentifier: string, etag: string, upload: BRegAttachmentUpload, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
   downloadAttachment(slot: BRegAttachmentSlot, recordIdentifier: string, proposalVersion: SafeInteger): Promise<RawOutcome>
   deleteAttachment(slot: BRegAttachmentSlot, recordIdentifier: string, etag: string, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
   getRecordJson(entityRoute: string, recordIdentifier: string, options?: RecordOptions | null): Promise<JsonOutcome>
   listRecordsJson(entityRoute: string, options?: ListOptions | null): Promise<JsonOutcome>
   continueListJson(continuation: ListContinuation): Promise<JsonOutcome>
-  lookupRecordJson(entityRoute: string, selector: string, valuesJson?: string | null, options?: RecordOptions | null): Promise<JsonOutcome>
+  getGeoJsonRecordJson(entityRoute: string, recordIdentifier: string, options?: GeoJsonOptions | null): Promise<JsonOutcome>
+  listGeoJsonRecordsJson(entityRoute: string, options?: GeoJsonListOptions | null): Promise<JsonOutcome<GeoJsonListContinuation>>
+  continueGeoJsonListJson(continuation: GeoJsonListContinuation): Promise<JsonOutcome<GeoJsonListContinuation>>
+  listCurrentRecordsJson(entityRoute: string, options?: CollectionOptions | null): Promise<JsonOutcome<CurrentListContinuation>>
+  continueCurrentListJson(continuation: CurrentListContinuation): Promise<JsonOutcome<CurrentListContinuation>>
+  listRecordsAsOfJson(entityRoute: string, options: AsOfListOptions): Promise<JsonOutcome<AsOfListContinuation>>
+  continueAsOfListJson(continuation: AsOfListContinuation): Promise<JsonOutcome<AsOfListContinuation>>
+  listSnapshotRecordsJson(entityRoute: string, options?: SnapshotListOptions | null): Promise<JsonOutcome<SnapshotListContinuation>>
+  continueSnapshotListJson(continuation: SnapshotListContinuation): Promise<JsonOutcome<SnapshotListContinuation>>
+  listRelationshipRecordsJson(entityRoute: string, recordIdentifier: string, pathRoute: string, options?: CollectionOptions | null): Promise<JsonOutcome<RelationshipListContinuation>>
+  continueRelationshipListJson(continuation: RelationshipListContinuation): Promise<JsonOutcome<RelationshipListContinuation>>
+  lookupRecordJson(entityRoute: string, selector: string, valuesJson?: string | null, options?: RecordProjectionOptions | null): Promise<JsonOutcome>
   createRecordJson(binding: BRegCreateBinding, dataJson: string, idempotencyKey: string, format?: RecordFormat | null): Promise<JsonOutcome>
   patchRecordJson(binding: BRegPatchBinding, recordIdentifier: string, etag: string, operationsJson: string, idempotencyKey: string, format?: RecordFormat | null): Promise<JsonOutcome>
   uploadAttachmentJson(slot: BRegAttachmentSlot, recordIdentifier: string, etag: string, upload: BRegAttachmentUpload, idempotencyKey: string, format?: RecordFormat | null): Promise<JsonOutcome>