@registrystack/client 0.29.0 → 0.31.0

package/breg/client.d.ts

@@ -1,9 +1,47 @@
 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
 
+export type WebhookVerificationRefusalCode =
+  | 'missing_header'
+  | 'malformed_signature'
+  | 'signature_mismatch'
+  | 'unsupported_version'
+
+export interface WebhookDeliveryInput {
+  method: string
+  path: string
+  headers: Readonly<Record<string, string>>
+  /** Exact bytes in a non-shared backing store. */
+  body: Buffer
+  /** Secret bytes in a non-shared backing store. */
+  key: Buffer
+}
+
+export interface VerifiedWebhookDelivery {
+  readonly id: string
+  readonly source: string
+  readonly type: string
+  readonly time: string
+  readonly dataschema: string
+  readonly generation: string
+  readonly attempt: string
+  readonly deliveryTime: string
+  readonly idempotencyKey: string
+  readonly body: Buffer
+}
+
+/**
+ * Authenticate one exact Base Registry Engine Version 1 webhook delivery.
+ * Apply delivery-time skew and idempotency policy before acting on the body.
+ */
+export declare function verifyWebhookDelivery(input: WebhookDeliveryInput): VerifiedWebhookDelivery
+
 export interface PrivateJwk {
   readonly kty: string
   readonly kid: string
@@ -15,7 +53,23 @@ export interface PrivateKeyJwtConfig {
   tokenEndpoint: string
   clientId: string
   clientKey: PrivateJwk
+  /**
+   * The audience of the client assertion (who checks the client's
+   * authentication). Defaults to the token endpoint URL. This is not the
+   * `resource` of the token request.
+   */
   audience?: string | null
+  /**
+   * The RFC 8707 resource indicator the token is requested for: the resource
+   * server's registered identifier, not a URL to fetch.
+   */
+  resource?: string | null
+  /**
+   * The scopes requested for the token, sent as one space-delimited `scope`
+   * parameter. A requested scope may narrow the client's registered
+   * permission set; it can never widen it.
+   */
+  scopes?: ReadonlyArray<string> | null
   assertionLifetimeSeconds?: SafeInteger | null
   refreshMarginSeconds?: SafeInteger | null
   requestTimeoutMilliseconds?: SafeInteger | null
@@ -24,6 +78,15 @@ export interface PrivateKeyJwtConfig {
   trustedRootCertificates?: string | null
 }
 
+/** OAuth credentials are returned to the caller. Keep them out of logs and persistence. */
+export class PrivateKeyJwt {
+  constructor(config: PrivateKeyJwtConfig)
+  /** Fresh RFC 8693 exchange. Requires resource and scopes; never shares the service cache. */
+  exchange(subjectToken: string): Promise<string>
+  /** Client credentials with the shared provider's bounded service-token cache. */
+  bearerToken(): Promise<string>
+}
+
 export type BaseRegistryAuthorization =
   | { static: string }
   | { privateKeyJwt: PrivateKeyJwtConfig }
@@ -40,17 +103,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 +154,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 +276,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 +316,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 +377,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 +410,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 +447,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 +465,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 +648,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 +691,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 +756,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 +771,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>