@registrystack/client 0.38.0 → 0.40.0

package/discovery/client.js

@@ -55,7 +55,7 @@ function inputError(kind) {
 
 function localAcceptanceError() {
   return new DiscoveryClientError({
-    kind: 'local_acceptance_refused',
+    kind: 'local-acceptance-refused',
     message: 'the relying application refused the advertised service',
   });
 }
@@ -222,14 +222,6 @@ class DiscoveryClient {
     }
   }
 
-  async searchRelayServices(query) {
-    try {
-      return await this.#inner.searchRelayServices(requestValue(query));
-    } catch (error) {
-      throw normalize(error, 'query');
-    }
-  }
-
   selectExact(response, request) {
     try {
       return this.#inner.selectExact(responseValue(response), requestValue(request));
@@ -246,9 +238,6 @@ class DiscoveryClient {
     return selectEvidenceService(response, request);
   }
 
-  selectRelayService(response, request) {
-    return selectRelayService(response, request);
-  }
 }
 
 function selectExact(response, request) {
@@ -278,14 +267,6 @@ function selectEvidenceService(response, request) {
   }
 }
 
-function selectRelayService(response, request) {
-  try {
-    return native.selectRelayService(responseValue(response), requestValue(request));
-  } catch (error) {
-    throw normalize(error, 'query');
-  }
-}
-
 function validateSelectionStructure(selection) {
   try {
     return native.validateSelectionStructure(requestValue(selection));
@@ -323,7 +304,6 @@ module.exports = {
   selectEvidenceAlternative,
   selectEvidenceService,
   selectExact,
-  selectRelayService,
   validateSelection,
   validateSelectionStructure,
 };

package/discovery/index.d.ts

@@ -6,11 +6,9 @@ export declare class DiscoveryClient {
   resolveEvidenceTypes(request: any): Promise<any>
   searchServices(filters: any): Promise<any>
   searchEvidenceServices(query: any): Promise<any>
-  searchRelayServices(query: any): Promise<any>
   selectExact(response: any, request: any): any
   selectEvidenceAlternative(response: any, evidenceTypeListId?: string | undefined | null): any
   selectEvidenceService(response: any, request: any): any
-  selectRelayService(response: any, request: any): any
 }
 
 export interface DiscoveryClientOptions {
@@ -29,8 +27,6 @@ export declare function selectEvidenceService(response: any, request: any): any
 
 export declare function selectExact(response: any, request: any): any
 
-export declare function selectRelayService(response: any, request: any): any
-
 export declare function validateSelection(selection: any): any
 
 export declare function validateSelectionStructure(selection: any): any

package/evidence/client.d.ts

@@ -351,7 +351,7 @@ export interface EvidenceRequestBatchSpec {
  *   is `protocol`
  * - `code`: `denied`, `protocol` (optional), `verification`, and any `token`
  *   failure whose `tokenKind` is `refused`
- * - `traceId`: `denied`, `not_available`, `protocol` (all optional)
+ * - `traceId`: `denied`, `not-available`, `protocol` (all optional)
  * - `retryAfterSeconds`: `denied`, `protocol` (both optional)
  * - `transportKind`: `transport`, and any `token` failure whose `tokenKind`
  *   is `transport`

package/evidence/index.d.ts

@@ -154,11 +154,8 @@ export declare class EvidenceClient {
 export declare class PreparedEvidenceRequest {
   /** The nonce this request carries. Retain it with the transaction record. */
   get requestNonce(): string
-  /**
-   * The closed verification policy, with the subject set as `prepare` left
-   * it.
-   */
-  get policyDocument(): any
+  /** The complete enveloped policy, with the subject set as `prepare` left it. */
+  get policyDocument(): { apiVersion: 'id.registrystack.org/formats/evidence/verification-policy/v1'; kind: 'EvidenceVerificationPolicy'; [field: string]: unknown }
   /**
    * `"acceptFirstUse"` or `{ pinned: [{ role, binding }, ...] }`, exactly as
    * this request was prepared.
@@ -178,7 +175,7 @@ export declare class PreparedEvidenceRequestBatch {
   /** Independently generated item nonces in request order. */
   get requestNonces(): Array<string>
   /** Independently closed policy documents in request order. */
-  get policyDocuments(): Array<any>
+  get policyDocuments(): Array<{ apiVersion: 'id.registrystack.org/formats/evidence/verification-policy/v1'; kind: 'EvidenceVerificationPolicy'; [field: string]: unknown }>
   /** Subject-verification stances in request order. */
   get subjectExpectations(): Array<any>
   /** Number of positional requests in this batch. */

package/index.d.ts

@@ -1,8 +1,8 @@
 import * as discovery from './discovery/client'
 import * as evidence from './evidence/client'
-import * as relay from './relay/client'
 import * as breg from './breg/client'
 import * as casework from './casework/client'
 import * as messaging from './messaging/client'
+import * as scheduling from './scheduling/client'
 
-export { discovery, evidence, relay, breg, casework, messaging }
+export { discovery, evidence, breg, casework, messaging, scheduling }

package/index.js

@@ -5,7 +5,7 @@
 // consumer imports, and `require()` sees the same six properties either way.
 exports.discovery = require('./discovery/client');
 exports.evidence = require('./evidence/client');
-exports.relay = require('./relay/client');
 exports.breg = require('./breg/client');
 exports.casework = require('./casework/client');
 exports.messaging = require('./messaging/client');
+exports.scheduling = require('./scheduling/client');

package/messaging/client.d.ts

@@ -14,6 +14,13 @@ export interface MessagingClientConfig {
   maxResponseBytes?: SafeInteger | null
   userAgent?: string | null
   trustedRootCertificates?: string | null
+  /**
+   * How many times a submission whose outcome is unknown is resent,
+   * identically and under the same idempotency key, before its error is
+   * returned: a whole number from 0 to 2, default 2; 0 sends it once. Any
+   * other value is a `configuration` error.
+   */
+  maxMutationRetries?: SafeInteger | null
 }
 
 export type Channel = 'email' | 'sms'
@@ -113,10 +120,21 @@ export type MessagingProblemCode =
   | 'template.locale-unavailable'
   | 'template.not-found'
   | 'template.render-refused'
-export type MessagingProtocolFailure = 'header_bounds' | 'trace_context' | 'media_type' | 'body' | 'problem' | 'status' | 'protocol'
+export type MessagingProtocolFailure = 'header-bounds' | 'trace-context' | 'media-type' | 'body' | 'problem' | 'status' | 'protocol'
 
 export class MessagingClientError extends Error {
-  readonly kind: 'configuration' | 'invalid_request' | 'transport' | 'problem' | 'protocol'
+  readonly kind: 'configuration' | 'invalid-request' | 'transport' | 'problem' | 'protocol'
+  /**
+   * Whether the request may have taken effect although this error was
+   * raised: a timeout or broken exchange after sending, an unusable answer,
+   * or a 5xx. When true, recover a keyed request by sending it again under
+   * the same idempotency key; a new key could apply it twice. False for a
+   * configuration or request defect, a connection never established, and
+   * every 4xx refusal. It is false for `410 idempotency.expired` too, but
+   * there an earlier submission under the key was accepted and its message
+   * may have been sent: reconcile that submission before choosing a new key.
+   */
+  readonly outcomeUnknown: boolean
   readonly code?: MessagingProblemCode
   readonly title?: string
   readonly detail?: string
@@ -124,8 +142,9 @@ export class MessagingClientError extends Error {
   readonly traceId?: string
   /**
    * Whole seconds a 429 limit refusal asked the caller to wait, from
-   * `Retry-After`, at most one day. Absent on every other failure; the
-   * client never waits or retries itself.
+   * `Retry-After`, at most one day. Absent on every other failure. The
+   * client never waits on a 429 or retries it; the wait is the caller's to
+   * honor.
    */
   readonly retryAfterSeconds?: SafeInteger
   readonly transportKind?: string

package/messaging/client.js

@@ -12,12 +12,19 @@ class MessagingClientError extends Error {
     super(envelope.message);
     this.name = 'MessagingClientError';
     this.kind = envelope.kind;
+    this.outcomeUnknown = envelope.outcomeUnknown === true;
     for (const field of ['code', 'title', 'detail', 'status', 'traceId', 'retryAfterSeconds', 'transportKind', 'protocolFailure']) {
       if (envelope[field] !== undefined && envelope[field] !== null) this[field] = envelope[field];
     }
   }
 }
 
+const FALLBACK_MESSAGES = {
+  configuration: 'Messaging client configuration is invalid',
+  'invalid-request': 'Messaging client arguments are invalid',
+  protocol: 'Registry Messaging client failed',
+};
+
 function normalized(error, fallbackKind) {
   if (error instanceof MessagingClientError) return error;
   if (error instanceof Error && typeof error.message === 'string') {
@@ -31,49 +38,51 @@ function normalized(error, fallbackKind) {
   if (fallbackKind) {
     return new MessagingClientError({
       kind: fallbackKind,
-      message: fallbackKind === 'configuration'
-        ? 'Messaging client configuration is invalid'
-        : 'Messaging client arguments are invalid',
+      message: FALLBACK_MESSAGES[fallbackKind],
+      // A rejection after the native client took the call may follow an
+      // exchange, so it leaves the outcome unknown as a native protocol
+      // failure does.
+      outcomeUnknown: fallbackKind === 'protocol',
     });
   }
   return error;
 }
 
-function cloneJson(value, budget, depth) {
-  if (depth > MAX_JSON_DEPTH || ++budget.nodes > MAX_JSON_NODES) throw normalized({}, 'invalid_request');
+function cloneJson(value, budget, depth, kind) {
+  if (depth > MAX_JSON_DEPTH || ++budget.nodes > MAX_JSON_NODES) throw normalized({}, kind);
   if (value === null || typeof value === 'boolean') return value;
   if (typeof value === 'string') {
     budget.bytes += Buffer.byteLength(value, 'utf8');
-    if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, 'invalid_request');
+    if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
     return value;
   }
   if (typeof value === 'number') {
     if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
-      throw normalized({}, 'invalid_request');
+      throw normalized({}, kind);
     }
     return value;
   }
   if (value === undefined || typeof value !== 'object' || isProxy(value)) {
-    throw normalized({}, 'invalid_request');
+    throw normalized({}, kind);
   }
   const array = Array.isArray(value);
   const prototype = Object.getPrototypeOf(value);
   if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
-    throw normalized({}, 'invalid_request');
+    throw normalized({}, kind);
   }
-  if (budget.active.has(value)) throw normalized({}, 'invalid_request');
+  if (budget.active.has(value)) throw normalized({}, kind);
   budget.active.add(value);
   try {
-    if (array) return value.map((member) => cloneJson(member, budget, depth + 1));
+    if (array) return value.map((member) => cloneJson(member, budget, depth + 1, kind));
     const result = Object.create(null);
     for (const key of Reflect.ownKeys(value)) {
-      if (typeof key !== 'string') throw normalized({}, 'invalid_request');
+      if (typeof key !== 'string') throw normalized({}, kind);
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, 'invalid_request');
+      if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, kind);
       if (descriptor.enumerable) {
         budget.bytes += Buffer.byteLength(key, 'utf8');
-        if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, 'invalid_request');
-        result[key] = cloneJson(descriptor.value, budget, depth + 1);
+        if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
+        result[key] = cloneJson(descriptor.value, budget, depth + 1, kind);
       }
     }
     return result;
@@ -82,8 +91,10 @@ function cloneJson(value, budget, depth) {
   }
 }
 
-function sanitize(value) {
-  return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0);
+// A refusal is reported as `kind`: `configuration` for the constructor's
+// settings, `invalid-request` for a method's arguments.
+function sanitize(value, kind) {
+  return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0, kind);
 }
 
 const NativeMessagingClient = native.MessagingClient;
@@ -91,7 +102,7 @@ const NativeMessagingClient = native.MessagingClient;
 class MessagingClient {
   constructor(config) {
     try {
-      this.native = new NativeMessagingClient(sanitize(config));
+      this.native = new NativeMessagingClient(sanitize(config, 'configuration'));
     } catch (error) {
       throw normalized(error, 'configuration');
     }
@@ -109,11 +120,11 @@ for (const [method, jsonIndexes] of [
   MessagingClient.prototype[method] = function (...args) {
     try {
       for (const index of jsonIndexes) {
-        if (args[index] !== undefined && args[index] !== null) args[index] = sanitize(args[index]);
+        if (args[index] !== undefined && args[index] !== null) args[index] = sanitize(args[index], 'invalid-request');
       }
-      return this.native[method](...args).catch((error) => { throw normalized(error); });
+      return this.native[method](...args).catch((error) => { throw normalized(error, 'protocol'); });
     } catch (error) {
-      throw normalized(error, 'invalid_request');
+      throw normalized(error, 'invalid-request');
     }
   };
 }

package/messaging/index.d.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 
 export declare class MessagingClient {
-  constructor(config: MessagingClientConfig)
+  constructor(config: any)
   health(): Promise<MessagingOutcome>
   ready(): Promise<MessagingOutcome>
   submit(token: string, idempotencyKey: string, request: any): Promise<MessagingOutcome>
@@ -11,15 +11,6 @@ export declare class MessagingClient {
   preview(token: string, templateId: string, version: string, request: any): Promise<MessagingOutcome>
 }
 
-export interface MessagingClientConfig {
-  baseUrl: string
-  requestTimeoutMilliseconds?: number
-  connectTimeoutMilliseconds?: number
-  maxResponseBytes?: number
-  userAgent?: string
-  trustedRootCertificates?: string
-}
-
 export interface MessagingOutcome {
   kind: string
   value: any

package/native.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const PACKAGE_VERSION = '0.38.0';
-const PRODUCTS = new Set(['discovery', 'evidence', 'relay', 'breg', 'casework', 'messaging']);
+const PACKAGE_VERSION = '0.40.0';
+const PRODUCTS = new Set(['discovery', 'evidence', 'breg', 'casework', 'messaging', 'scheduling']);
 
 function target() {
   if (process.platform === 'darwin' && process.arch === 'arm64') return 'darwin-arm64';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@registrystack/client",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "Unified Node.js client for Registry Stack products.",
   "license": "Apache-2.0",
   "homepage": "https://docs.registrystack.org/reference/client-api/",
@@ -12,10 +12,10 @@
     "registrystack",
     "discovery",
     "evidence",
-    "relay",
     "breg",
     "casework",
-    "messaging"
+    "messaging",
+    "scheduling"
   ],
   "publishConfig": {
     "access": "public",
@@ -40,10 +40,10 @@
     "native.js",
     "discovery",
     "evidence",
-    "relay",
     "breg",
     "casework",
-    "messaging"
+    "messaging",
+    "scheduling"
   ],
   "engines": {
     "node": ">=22.12.0"
@@ -55,12 +55,12 @@
     "check:types": "tsc --noEmit --strict --skipLibCheck false --types node --moduleResolution node16 --module node16 --target es2022 index.d.ts __test__/facade.test-d.ts"
   },
   "devDependencies": {
-    "@types/node": "22.20.4",
+    "@types/node": "22.20.5",
     "typescript": "6.0.3"
   },
   "optionalDependencies": {
-    "@registrystack/client-darwin-arm64": "0.38.0",
-    "@registrystack/client-linux-arm64-gnu": "0.38.0",
-    "@registrystack/client-linux-x64-gnu": "0.38.0"
+    "@registrystack/client-darwin-arm64": "0.40.0",
+    "@registrystack/client-linux-arm64-gnu": "0.40.0",
+    "@registrystack/client-linux-x64-gnu": "0.40.0"
   }
 }

package/scheduling/client.d.ts

@@ -0,0 +1,226 @@
+/** An integer for which `Number.isSafeInteger` is true. */
+export type SafeInteger = number
+/**
+ * An RFC 3339 instant. Instants the binding sends are parsed and normalized
+ * to UTC before any request; instants it answers are UTC.
+ */
+export type Instant = string
+export type JsonScalar = string | number | boolean | null
+export type JsonValue = JsonScalar | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }
+
+export interface SchedulingClientConfig {
+  baseUrl: string
+  requestTimeoutMilliseconds?: SafeInteger | null
+  connectTimeoutMilliseconds?: SafeInteger | null
+  maxResponseBytes?: SafeInteger | null
+  userAgent?: string | null
+  trustedRootCertificates?: string | null
+  /**
+   * How many times a keyed command (hold, appointment create, reschedule,
+   * cancel) whose outcome is unknown is resent, identically and under the
+   * same idempotency key, before its error is returned: a whole number from 0
+   * to 2, default 2; 0 sends it once. Any other value is a `configuration`
+   * error.
+   */
+  maxMutationRetries?: SafeInteger | null
+}
+
+/** An opaque record link Scheduling retains with a hold or appointment. */
+export interface ExternalReference {
+  product: string
+  recordType: string
+  identifier: string
+}
+
+export interface PartyCounts { recipients: SafeInteger; attendees: SafeInteger }
+
+/** One admission: the offering, start, and party a hold or booking asks capacity for. */
+export interface AdmissionRequest {
+  offering: string
+  start: Instant
+  party: PartyCounts
+  channel?: string | null
+  duplicateKey?: string | null
+  policyRevision: SafeInteger
+  windowRevision?: SafeInteger | null
+  capabilities: ReadonlyArray<string>
+  prerequisites: ReadonlyArray<string>
+  externalReferences?: ReadonlyArray<ExternalReference>
+}
+
+/** Exactly one of `hold` (confirm a held claim) or `admission` (book directly). */
+export type CreateAppointmentRequest =
+  | { hold: string; admission?: null }
+  | { admission: AdmissionRequest; hold?: null }
+
+export interface RescheduleAppointmentRequest { observedRevision: SafeInteger; admission: AdmissionRequest }
+export interface CancelAppointmentRequest { observedRevision: SafeInteger; reason?: string | null }
+
+export interface AvailabilityQuery {
+  start?: Instant | null
+  end?: Instant | null
+  cursor?: string | null
+  limit?: SafeInteger | null
+}
+export interface PageQuery { cursor?: string | null; limit?: SafeInteger | null }
+
+export interface SchedulingServiceDocument { schedulingId: string; policyRevision: SafeInteger; policyDigest: string }
+export interface ServiceDocument { id: string; label: string }
+export type SchedulingMode = 'exact-time' | 'arrival-window'
+export interface ReminderDocument { minutesBefore: SafeInteger }
+export interface WindowDocument { id: string; revision: SafeInteger; start: Instant; end: Instant; units: SafeInteger }
+export interface OfferingDocument {
+  id: string
+  service: string
+  label: string
+  mode: SchedulingMode
+  location: string
+  leadTimeMinutes: SafeInteger
+  horizonDays: SafeInteger
+  cancellationCutoffMinutes: SafeInteger
+  durationMinutes: SafeInteger | null
+  bufferBeforeMinutes: SafeInteger | null
+  bufferAfterMinutes: SafeInteger | null
+  startIncrementMinutes: SafeInteger | null
+  maxRecipients: SafeInteger | null
+  window: WindowDocument | null
+  reminders: ReadonlyArray<ReminderDocument>
+  requiresCapabilities: ReadonlyArray<string>
+  prerequisites: ReadonlyArray<string>
+}
+export interface ResourceDocument { resourceId: string; pool: string; capabilities: ReadonlyArray<string>; available: boolean }
+export interface LocationDocument { locationId: string; timezone: string }
+
+/** Exact-time offerings answer grid slots; arrival-window offerings answer windows. */
+export type AvailabilityEntry =
+  | { kind: 'slot'; start: Instant; end: Instant; free: SafeInteger }
+  | { kind: 'window'; window: string; start: Instant; end: Instant; remaining: SafeInteger; channelRemaining: SafeInteger | null }
+
+export interface PageDocument<T> { items: ReadonlyArray<T>; nextCursor: string | null }
+
+export interface HoldDocument {
+  holdId: string
+  offering: string
+  start: Instant
+  end: Instant
+  resource: string | null
+  units: SafeInteger
+  expiresAt: Instant
+  policyRevision: SafeInteger
+  externalReferences: ReadonlyArray<ExternalReference>
+}
+
+export type AppointmentState = 'confirmed' | 'cancelled'
+export interface AppointmentDocument {
+  appointmentId: string
+  offering: string
+  start: Instant
+  end: Instant
+  resource: string | null
+  units: SafeInteger
+  channel: string | null
+  revision: SafeInteger
+  state: AppointmentState
+  policyRevision: SafeInteger
+  createdAt: Instant
+  cancelledAt: Instant | null
+  externalReferences: ReadonlyArray<ExternalReference>
+}
+
+export interface AppointmentHistoryEntryDocument {
+  eventId: string
+  kind: string
+  revision: SafeInteger
+  occurredAt: Instant
+  actor: string | null
+  detail: JsonValue
+}
+
+export interface ExplainDocument {
+  offering: string
+  start: Instant
+  publicCode?: string
+  detailedCode?: string
+  explanation?: string
+}
+
+export interface SchedulingOutcome<T> { kind: 'complete'; value: T; traceId: string }
+
+/** The closed catalogue: the client answers any other code as a protocol failure. */
+export type SchedulingProblemCode =
+  | 'authentication.refused'
+  | 'booking.duplicate-active'
+  | 'cancellation.cutoff-passed'
+  | 'capability.unmatched'
+  | 'capacity.exhausted'
+  | 'cursor.expired'
+  | 'cursor.invalid'
+  | 'eligibility.unavailable'
+  | 'hold.expired'
+  | 'hold.released'
+  | 'hook.unavailable'
+  | 'horizon.outside'
+  | 'idempotency.expired'
+  | 'idempotency.key-reused'
+  | 'location.closed'
+  | 'operation.not-authorized'
+  | 'party.capacity-inadequate'
+  | 'policy.changed'
+  | 'precondition.failed'
+  | 'precondition.required'
+  | 'prerequisite.missing'
+  | 'profile.not-authorized'
+  | 'request.body-too-large'
+  | 'request.invalid'
+  | 'request.method-not-allowed'
+  | 'request.not-found'
+  | 'request.unprocessable'
+  | 'request.unsupported-media-type'
+  | 'resource.unavailable'
+  | 'revision.mismatch'
+  | 'schedule.unpublished'
+  | 'service.unavailable'
+export type SchedulingProtocolFailure = 'header-bounds' | 'trace-context' | 'media-type' | 'body' | 'problem' | 'status' | 'protocol'
+
+export class SchedulingClientError extends Error {
+  readonly kind: 'configuration' | 'invalid-request' | 'transport' | 'problem' | 'protocol'
+  /**
+   * Whether the request may have taken effect although this error was
+   * raised: a timeout or broken exchange after sending, an unusable answer,
+   * or a 5xx. When true, recover a keyed request by sending it again under
+   * the same idempotency key; a new key could apply it twice. False for a
+   * configuration or request defect, a connection never established, and
+   * every 4xx refusal. It is false for `410 idempotency.expired` too, but
+   * there an earlier attempt under the key was answered and may have
+   * committed: read an appointment by its external reference or identifier
+   * before choosing a new key. A hold cannot be read and expires on its own,
+   * so start a new request.
+   */
+  readonly outcomeUnknown: boolean
+  readonly code?: SchedulingProblemCode
+  readonly title?: string
+  readonly detail?: string
+  readonly status?: SafeInteger
+  readonly traceId?: string
+  readonly transportKind?: string
+  readonly protocolFailure?: SchedulingProtocolFailure
+}
+
+export class SchedulingClient {
+  constructor(config: SchedulingClientConfig)
+  getScheduling(token: string): Promise<SchedulingOutcome<SchedulingServiceDocument>>
+  listServices(token: string, cursor?: string | null): Promise<SchedulingOutcome<PageDocument<ServiceDocument>>>
+  listOfferings(token: string, cursor?: string | null): Promise<SchedulingOutcome<PageDocument<OfferingDocument>>>
+  availability(token: string, offering: string, query?: AvailabilityQuery | null): Promise<SchedulingOutcome<PageDocument<AvailabilityEntry>>>
+  explain(token: string, offering: string, start: Instant): Promise<SchedulingOutcome<ExplainDocument>>
+  createHold(token: string, idempotencyKey: string, request: AdmissionRequest): Promise<SchedulingOutcome<HoldDocument>>
+  releaseHold(token: string, holdId: string): Promise<SchedulingOutcome<null>>
+  createAppointment(token: string, idempotencyKey: string, request: CreateAppointmentRequest): Promise<SchedulingOutcome<AppointmentDocument>>
+  getAppointment(token: string, appointmentId: string): Promise<SchedulingOutcome<AppointmentDocument>>
+  listAppointments(token: string, reference: ExternalReference, page?: PageQuery | null): Promise<SchedulingOutcome<PageDocument<AppointmentDocument>>>
+  rescheduleAppointment(token: string, appointmentId: string, idempotencyKey: string, request: RescheduleAppointmentRequest): Promise<SchedulingOutcome<AppointmentDocument>>
+  cancelAppointment(token: string, appointmentId: string, idempotencyKey: string, request: CancelAppointmentRequest): Promise<SchedulingOutcome<AppointmentDocument>>
+  appointmentHistory(token: string, appointmentId: string, cursor?: string | null): Promise<SchedulingOutcome<PageDocument<AppointmentHistoryEntryDocument>>>
+  listResources(token: string, cursor?: string | null): Promise<SchedulingOutcome<PageDocument<ResourceDocument>>>
+  listLocations(token: string, cursor?: string | null): Promise<SchedulingOutcome<PageDocument<LocationDocument>>>
+}