@registrystack/client 0.39.0 → 0.41.0

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');
     }
@@ -102,6 +113,7 @@ for (const [method, jsonIndexes] of [
   ['health', []],
   ['ready', []],
   ['submit', [2]],
+  ['messageReceipt', [2]],
   ['message', []],
   ['cancel', []],
   ['preview', [3]],
@@ -109,11 +121,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,24 +2,16 @@
 /* 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>
+  messageReceipt(token: string, idempotencyKey: string, request: any): Promise<MessagingOutcome>
   message(token: string, messageId: string): Promise<MessagingOutcome>
   cancel(token: string, messageId: string): Promise<MessagingOutcome>
   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.39.0';
-const PRODUCTS = new Set(['discovery', 'evidence', 'breg', 'casework', 'messaging']);
+const PACKAGE_VERSION = '0.41.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.39.0",
+  "version": "0.41.0",
   "description": "Unified Node.js client for Registry Stack products.",
   "license": "Apache-2.0",
   "homepage": "https://docs.registrystack.org/reference/client-api/",
@@ -14,7 +14,8 @@
     "evidence",
     "breg",
     "casework",
-    "messaging"
+    "messaging",
+    "scheduling"
   ],
   "publishConfig": {
     "access": "public",
@@ -41,10 +42,11 @@
     "evidence",
     "breg",
     "casework",
-    "messaging"
+    "messaging",
+    "scheduling"
   ],
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=24.11.0"
   },
   "scripts": {
     "sync": "python3 ../../release/scripts/sync-registry-client-node.py",
@@ -53,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": "24.19.1",
     "typescript": "6.0.3"
   },
   "optionalDependencies": {
-    "@registrystack/client-darwin-arm64": "0.39.0",
-    "@registrystack/client-linux-arm64-gnu": "0.39.0",
-    "@registrystack/client-linux-x64-gnu": "0.39.0"
+    "@registrystack/client-darwin-arm64": "0.41.0",
+    "@registrystack/client-linux-arm64-gnu": "0.41.0",
+    "@registrystack/client-linux-x64-gnu": "0.41.0"
   }
 }

package/scheduling/client.d.ts

@@ -0,0 +1,229 @@
+/** 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'
+  | 'receipt.unresolved'
+  | '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>>
+  /** Observe the original success using the same body/key and current token; never resend or mutate. */
+  appointmentReceipt(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>>>
+}

package/scheduling/client.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const { types: { isProxy } } = require('node:util');
+const native = require('./index');
+
+const MAX_JSON_DEPTH = 64;
+const MAX_JSON_NODES = 20_000;
+const MAX_JSON_STRING_BYTES = 1024 * 1024;
+
+class SchedulingClientError extends Error {
+  constructor(envelope) {
+    super(envelope.message);
+    this.name = 'SchedulingClientError';
+    this.kind = envelope.kind;
+    this.outcomeUnknown = envelope.outcomeUnknown === true;
+    for (const field of ['code', 'title', 'detail', 'status', 'traceId', 'transportKind', 'protocolFailure']) {
+      if (envelope[field] !== undefined && envelope[field] !== null) this[field] = envelope[field];
+    }
+  }
+}
+
+const FALLBACK_MESSAGES = {
+  configuration: 'Scheduling client configuration is invalid',
+  'invalid-request': 'Scheduling client arguments are invalid',
+  protocol: 'Registry Scheduling client failed',
+};
+
+function normalized(error, fallbackKind) {
+  if (error instanceof SchedulingClientError) return error;
+  if (error instanceof Error && typeof error.message === 'string') {
+    try {
+      const envelope = JSON.parse(error.message);
+      if (envelope && typeof envelope.kind === 'string') return new SchedulingClientError(envelope);
+    } catch {
+      // napi argument conversion errors have no mapped envelope.
+    }
+  }
+  if (fallbackKind) {
+    return new SchedulingClientError({
+      kind: fallbackKind,
+      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, 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({}, kind);
+    return value;
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+      throw normalized({}, kind);
+    }
+    return value;
+  }
+  if (value === undefined || typeof value !== 'object' || isProxy(value)) {
+    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({}, kind);
+  }
+  if (budget.active.has(value)) throw normalized({}, kind);
+  budget.active.add(value);
+  try {
+    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({}, kind);
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      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({}, kind);
+        result[key] = cloneJson(descriptor.value, budget, depth + 1, kind);
+      }
+    }
+    return result;
+  } finally {
+    budget.active.delete(value);
+  }
+}
+
+// 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 NativeSchedulingClient = native.SchedulingClient;
+
+class SchedulingClient {
+  constructor(config) {
+    try {
+      this.native = new NativeSchedulingClient(sanitize(config, 'configuration'));
+    } catch (error) {
+      throw normalized(error, 'configuration');
+    }
+  }
+}
+
+for (const [method, jsonIndexes] of [
+  ['getScheduling', []],
+  ['listServices', []],
+  ['listOfferings', []],
+  ['availability', [2]],
+  ['explain', []],
+  ['createHold', [2]],
+  ['releaseHold', []],
+  ['createAppointment', [2]],
+  ['appointmentReceipt', [2]],
+  ['getAppointment', []],
+  ['listAppointments', [1, 2]],
+  ['rescheduleAppointment', [3]],
+  ['cancelAppointment', [3]],
+  ['appointmentHistory', []],
+  ['listResources', []],
+  ['listLocations', []],
+]) {
+  SchedulingClient.prototype[method] = function (...args) {
+    try {
+      for (const index of jsonIndexes) {
+        if (args[index] !== undefined && args[index] !== null) args[index] = sanitize(args[index], 'invalid-request');
+      }
+      return this.native[method](...args).catch((error) => { throw normalized(error, 'protocol'); });
+    } catch (error) {
+      throw normalized(error, 'invalid-request');
+    }
+  };
+}
+
+module.exports = { SchedulingClient, SchedulingClientError };

package/scheduling/index.d.ts

@@ -0,0 +1,28 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+
+export declare class SchedulingClient {
+  constructor(config: any)
+  getScheduling(token: string): Promise<SchedulingOutcome>
+  listServices(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  listOfferings(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  availability(token: string, offering: string, query?: any | undefined | null): Promise<SchedulingOutcome>
+  explain(token: string, offering: string, start: string): Promise<SchedulingOutcome>
+  createHold(token: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  releaseHold(token: string, holdId: string): Promise<SchedulingOutcome>
+  createAppointment(token: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  appointmentReceipt(token: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  getAppointment(token: string, appointmentId: string): Promise<SchedulingOutcome>
+  listAppointments(token: string, reference: any, page?: any | undefined | null): Promise<SchedulingOutcome>
+  rescheduleAppointment(token: string, appointmentId: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  cancelAppointment(token: string, appointmentId: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  appointmentHistory(token: string, appointmentId: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  listResources(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  listLocations(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+}
+
+export interface SchedulingOutcome {
+  kind: string
+  value: any
+  traceId: string
+}

package/scheduling/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../native').load('scheduling');