kaafil-js 0.1.0-beta.0

package/dist/client-entry.js

@@ -0,0 +1,1739 @@
+// src/generated/security.ts
+var SecuritySchemeId = {
+  AgencyAdminAuth: "agencyAdminAuth",
+  ApiKeyAuth: "apiKeyAuth",
+  ManagerAuth: "managerAuth",
+  ShareAuth: "shareAuth"
+};
+var SECURITY_SCHEME_CARRIERS = {
+  agencyAdminAuth: { kind: "bearer" },
+  apiKeyAuth: { kind: "header", headerName: "X-API-Key" },
+  consoleAuth: { kind: "cookie", cookieName: "kaafil_console_session" },
+  managerAuth: { kind: "bearer" },
+  platformAdminAuth: { kind: "bearer" },
+  shareAuth: { kind: "bearer" }
+};
+var OperationId = {
+  ListJourneyTriggers: "listJourneyTriggers",
+  ListTripVendors: "listTripVendors",
+  PatchJourneyTrigger: "patchJourneyTrigger",
+  ReadJourney: "readJourney",
+  ReadJourneyCapabilities: "readJourneyCapabilities",
+  RebuildJourney: "rebuildJourney",
+  RunJourneyStep: "runJourneyStep"};
+var OPERATION_SECURITY = {
+  acceptConsoleInvite: [],
+  acceptPlatformAdminInvite: [],
+  addChecklistItem: ["managerAuth"],
+  addItineraryItem: ["managerAuth"],
+  adjustFloat: ["managerAuth", "apiKeyAuth", "agencyAdminAuth"],
+  assignManager: ["apiKeyAuth"],
+  assignPickupTraveller: ["managerAuth"],
+  assignRoomingBed: ["managerAuth"],
+  assignSeating: ["managerAuth"],
+  autoAssignRooming: ["managerAuth"],
+  autoAssignSeating: ["managerAuth"],
+  boardPickupTraveller: ["managerAuth"],
+  cancelTrip: ["apiKeyAuth"],
+  changeOwnPlatformPassword: ["platformAdminAuth"],
+  claimStatusIngest: ["apiKeyAuth"],
+  closePickupStop: ["managerAuth"],
+  confirmFileUpload: ["managerAuth"],
+  consoleLogin: [],
+  consoleLogout: ["consoleAuth"],
+  consoleSwitchPlane: ["consoleAuth"],
+  createApiKey: ["consoleAuth"],
+  createConsoleUser: ["consoleAuth"],
+  createPickupStop: ["managerAuth"],
+  createPlatformAdmin: ["platformAdminAuth"],
+  createPlatformPartner: ["platformAdminAuth"],
+  createPlatformPartnerConsoleUser: ["platformAdminAuth"],
+  createRoomingRoom: ["managerAuth"],
+  createRoomingStayWindow: ["managerAuth"],
+  createSeatingVehicle: ["managerAuth"],
+  createTrekWalkIn: ["managerAuth"],
+  deleteChecklistItem: ["managerAuth"],
+  deleteItineraryItem: ["managerAuth"],
+  deletePickupStop: ["managerAuth"],
+  deletePlatformPartnerPlan: ["platformAdminAuth"],
+  deleteRoomingRoom: ["managerAuth"],
+  deleteRoomingStayWindow: ["managerAuth"],
+  deleteSeatingVehicle: ["managerAuth"],
+  editWebhookEndpoint: ["consoleAuth"],
+  getTrip: ["apiKeyAuth"],
+  health: [],
+  healthV1: [],
+  inspectConsoleInvite: [],
+  inspectPlatformAdminInvite: [],
+  issueFloat: ["managerAuth", "apiKeyAuth", "agencyAdminAuth"],
+  linkExpenseReceipt: ["managerAuth"],
+  linkSeatingManager: ["managerAuth"],
+  listAgencies: ["consoleAuth"],
+  listApiKeys: ["consoleAuth"],
+  listChecklistTemplates: ["managerAuth", "apiKeyAuth"],
+  listCollections: ["managerAuth", "apiKeyAuth"],
+  listConsoleTrips: ["consoleAuth"],
+  listConsoleUsers: ["consoleAuth"],
+  listEligibleCollections: ["managerAuth", "apiKeyAuth"],
+  listEvents: ["apiKeyAuth"],
+  listExpenses: ["managerAuth", "apiKeyAuth"],
+  listJourneyTriggers: ["apiKeyAuth", "agencyAdminAuth"],
+  listPickupStops: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  listPlatformAdmins: ["platformAdminAuth"],
+  listPlatformPartnerApiKeys: ["platformAdminAuth"],
+  listPlatformPartnerConsoleUsers: ["platformAdminAuth"],
+  listPlatformPartners: ["platformAdminAuth"],
+  listRoomingStayWindows: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  listTripVendors: ["apiKeyAuth", "managerAuth", "agencyAdminAuth"],
+  listWebhookDeliveries: ["apiKeyAuth"],
+  listWebhookEndpoints: ["consoleAuth"],
+  logExpense: ["managerAuth"],
+  mintAgencyAdminTokens: ["apiKeyAuth"],
+  mintManagerTokens: ["apiKeyAuth"],
+  mintShareToken: ["apiKeyAuth"],
+  patchAgencyEntitlement: ["consoleAuth"],
+  patchChecklistItem: ["managerAuth"],
+  patchConsoleUser: ["consoleAuth"],
+  patchItineraryDay: ["managerAuth"],
+  patchItineraryItem: ["managerAuth"],
+  patchJourneyTrigger: ["apiKeyAuth", "agencyAdminAuth"],
+  patchPickupStop: ["managerAuth"],
+  patchPlatformAdmin: ["platformAdminAuth"],
+  patchPlatformPartnerConsoleUser: ["platformAdminAuth"],
+  patchRoomingRoom: ["managerAuth"],
+  patchRoomingStayWindow: ["managerAuth"],
+  patchSeatingVehicle: ["managerAuth"],
+  platformLogin: [],
+  platformLogout: ["platformAdminAuth"],
+  platformMe: ["platformAdminAuth"],
+  platformRefreshTokens: ["platformAdminAuth"],
+  postponeTrek: ["managerAuth"],
+  pullChecklistTemplate: ["managerAuth"],
+  pushBulkTrips: ["apiKeyAuth"],
+  pushManifest: ["apiKeyAuth"],
+  pushTripBalances: ["apiKeyAuth"],
+  putPlatformPartnerPlan: ["platformAdminAuth"],
+  readAgencyEntitlement: ["consoleAuth"],
+  readApiKey: ["consoleAuth"],
+  readChecklistAggregate: ["managerAuth", "apiKeyAuth"],
+  readConsoleAudit: ["consoleAuth"],
+  readConsoleChecklist: ["consoleAuth"],
+  readConsoleItinerary: ["consoleAuth"],
+  readConsolePickups: ["consoleAuth"],
+  readConsoleRooming: ["consoleAuth"],
+  readConsoleSeating: ["consoleAuth"],
+  readConsoleUserInvite: ["consoleAuth"],
+  readEndpointDeliveries: ["consoleAuth"],
+  readEndpointDelivery: ["consoleAuth"],
+  readEntitlementCatalog: ["consoleAuth"],
+  readExpense: ["managerAuth", "apiKeyAuth"],
+  readFile: ["managerAuth", "apiKeyAuth"],
+  readFileUrl: ["managerAuth", "apiKeyAuth"],
+  readFloatLedger: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  readFloatSummary: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  readIngestLog: ["consoleAuth"],
+  readItinerary: ["apiKeyAuth", "managerAuth", "agencyAdminAuth"],
+  readItineraryChangeLog: ["apiKeyAuth", "managerAuth", "agencyAdminAuth"],
+  readJourney: ["apiKeyAuth", "managerAuth", "agencyAdminAuth"],
+  readJourneyCapabilities: ["apiKeyAuth", "managerAuth", "agencyAdminAuth"],
+  readManifestByPickup: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  readPlan: ["consoleAuth"],
+  readPlatformPartner: ["platformAdminAuth"],
+  readRoomingBoard: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  readSeatingBoard: ["managerAuth", "agencyAdminAuth", "apiKeyAuth"],
+  readShareToken: ["apiKeyAuth"],
+  readTrekBoard: ["managerAuth", "apiKeyAuth"],
+  readTrekWalkInMeta: ["managerAuth", "apiKeyAuth"],
+  readUsage: ["consoleAuth"],
+  readWebhookDelivery: ["apiKeyAuth"],
+  readWebhookEndpoint: ["consoleAuth"],
+  rebuildJourney: ["apiKeyAuth"],
+  recordCollection: ["managerAuth"],
+  redeliverEndpointDelivery: ["consoleAuth"],
+  redeliverWebhookDelivery: ["apiKeyAuth"],
+  refreshAgencyAdminTokens: ["agencyAdminAuth"],
+  refreshManagerTokens: ["managerAuth"],
+  registerWebhookEndpoint: ["consoleAuth"],
+  reissueConsoleUserInvite: ["consoleAuth"],
+  reissuePlatformAdminInvite: ["platformAdminAuth"],
+  reissuePlatformPartnerConsoleUserInvite: ["platformAdminAuth"],
+  removeFromManifest: ["apiKeyAuth"],
+  renamePlatformPartner: ["platformAdminAuth"],
+  reopenPickupStop: ["managerAuth"],
+  reorderItineraryItem: ["managerAuth"],
+  reorderPickupStops: ["managerAuth"],
+  replayWebhookEndpoint: ["apiKeyAuth"],
+  requestFileUpload: ["managerAuth"],
+  resetPlatformPartnerConsoleUser: ["platformAdminAuth"],
+  returnFloat: ["managerAuth"],
+  revokeApiKey: ["consoleAuth"],
+  revokePlatformPartnerApiKey: ["platformAdminAuth"],
+  revokeShareToken: ["apiKeyAuth"],
+  rotateApiKey: ["consoleAuth"],
+  rotateWebhookEndpointSecret: ["consoleAuth"],
+  runJourneyStep: ["apiKeyAuth"],
+  setPlatformPartnerStatus: ["platformAdminAuth"],
+  submitExpenseClaim: ["managerAuth"],
+  toggleChecklistItem: ["managerAuth"],
+  unassignManager: ["apiKeyAuth"],
+  unlinkSeatingManager: ["managerAuth"],
+  upsertAgencyAdmin: ["apiKeyAuth"],
+  upsertManager: ["apiKeyAuth"],
+  upsertTravellerProfile: ["apiKeyAuth"],
+  upsertTrip: ["apiKeyAuth"],
+  voidCollection: ["managerAuth"],
+  voidExpense: ["managerAuth"],
+  withdrawExpenseClaim: ["managerAuth"]
+};
+var OPERATION_ACCEPTS_IDEMPOTENCY_KEY = {
+  acceptConsoleInvite: true,
+  acceptPlatformAdminInvite: true,
+  addChecklistItem: true,
+  addItineraryItem: true,
+  adjustFloat: true,
+  assignManager: true,
+  assignPickupTraveller: true,
+  assignRoomingBed: true,
+  assignSeating: true,
+  autoAssignRooming: true,
+  autoAssignSeating: true,
+  boardPickupTraveller: true,
+  cancelTrip: true,
+  changeOwnPlatformPassword: false,
+  claimStatusIngest: true,
+  closePickupStop: true,
+  confirmFileUpload: true,
+  consoleLogin: false,
+  consoleLogout: false,
+  consoleSwitchPlane: false,
+  createApiKey: true,
+  createConsoleUser: true,
+  createPickupStop: true,
+  createPlatformAdmin: false,
+  createPlatformPartner: false,
+  createPlatformPartnerConsoleUser: false,
+  createRoomingRoom: true,
+  createRoomingStayWindow: true,
+  createSeatingVehicle: true,
+  createTrekWalkIn: true,
+  deleteChecklistItem: false,
+  deleteItineraryItem: false,
+  deletePickupStop: false,
+  deletePlatformPartnerPlan: false,
+  deleteRoomingRoom: false,
+  deleteRoomingStayWindow: false,
+  deleteSeatingVehicle: false,
+  editWebhookEndpoint: true,
+  getTrip: false,
+  health: false,
+  healthV1: false,
+  inspectConsoleInvite: false,
+  inspectPlatformAdminInvite: false,
+  issueFloat: true,
+  linkExpenseReceipt: true,
+  linkSeatingManager: true,
+  listAgencies: false,
+  listApiKeys: false,
+  listChecklistTemplates: false,
+  listCollections: false,
+  listConsoleTrips: false,
+  listConsoleUsers: false,
+  listEligibleCollections: false,
+  listEvents: false,
+  listExpenses: false,
+  listJourneyTriggers: false,
+  listPickupStops: false,
+  listPlatformAdmins: false,
+  listPlatformPartnerApiKeys: false,
+  listPlatformPartnerConsoleUsers: false,
+  listPlatformPartners: false,
+  listRoomingStayWindows: false,
+  listTripVendors: false,
+  listWebhookDeliveries: false,
+  listWebhookEndpoints: false,
+  logExpense: true,
+  mintAgencyAdminTokens: false,
+  mintManagerTokens: false,
+  mintShareToken: true,
+  patchAgencyEntitlement: true,
+  patchChecklistItem: false,
+  patchConsoleUser: true,
+  patchItineraryDay: false,
+  patchItineraryItem: false,
+  patchJourneyTrigger: true,
+  patchPickupStop: false,
+  patchPlatformAdmin: false,
+  patchPlatformPartnerConsoleUser: false,
+  patchRoomingRoom: false,
+  patchRoomingStayWindow: false,
+  patchSeatingVehicle: false,
+  platformLogin: true,
+  platformLogout: false,
+  platformMe: false,
+  platformRefreshTokens: true,
+  postponeTrek: true,
+  pullChecklistTemplate: true,
+  pushBulkTrips: true,
+  pushManifest: true,
+  pushTripBalances: true,
+  putPlatformPartnerPlan: false,
+  readAgencyEntitlement: false,
+  readApiKey: false,
+  readChecklistAggregate: false,
+  readConsoleAudit: false,
+  readConsoleChecklist: false,
+  readConsoleItinerary: false,
+  readConsolePickups: false,
+  readConsoleRooming: false,
+  readConsoleSeating: false,
+  readConsoleUserInvite: false,
+  readEndpointDeliveries: false,
+  readEndpointDelivery: false,
+  readEntitlementCatalog: false,
+  readExpense: false,
+  readFile: false,
+  readFileUrl: false,
+  readFloatLedger: false,
+  readFloatSummary: false,
+  readIngestLog: false,
+  readItinerary: false,
+  readItineraryChangeLog: false,
+  readJourney: false,
+  readJourneyCapabilities: false,
+  readManifestByPickup: false,
+  readPlan: false,
+  readPlatformPartner: false,
+  readRoomingBoard: false,
+  readSeatingBoard: false,
+  readShareToken: false,
+  readTrekBoard: false,
+  readTrekWalkInMeta: false,
+  readUsage: false,
+  readWebhookDelivery: false,
+  readWebhookEndpoint: false,
+  rebuildJourney: true,
+  recordCollection: true,
+  redeliverEndpointDelivery: true,
+  redeliverWebhookDelivery: true,
+  refreshAgencyAdminTokens: false,
+  refreshManagerTokens: false,
+  registerWebhookEndpoint: true,
+  reissueConsoleUserInvite: true,
+  reissuePlatformAdminInvite: false,
+  reissuePlatformPartnerConsoleUserInvite: false,
+  removeFromManifest: true,
+  renamePlatformPartner: false,
+  reopenPickupStop: true,
+  reorderItineraryItem: true,
+  reorderPickupStops: true,
+  replayWebhookEndpoint: true,
+  requestFileUpload: true,
+  resetPlatformPartnerConsoleUser: false,
+  returnFloat: true,
+  revokeApiKey: true,
+  revokePlatformPartnerApiKey: false,
+  revokeShareToken: false,
+  rotateApiKey: true,
+  rotateWebhookEndpointSecret: true,
+  runJourneyStep: true,
+  setPlatformPartnerStatus: false,
+  submitExpenseClaim: true,
+  toggleChecklistItem: true,
+  unassignManager: true,
+  unlinkSeatingManager: false,
+  upsertAgencyAdmin: true,
+  upsertManager: true,
+  upsertTravellerProfile: true,
+  upsertTrip: true,
+  voidCollection: false,
+  voidExpense: false,
+  withdrawExpenseClaim: false
+};
+
+// src/generated/error-codes.ts
+var KaafilErrorCode = {
+  BusinessRuleViolation: "BUSINESS_RULE_VIOLATION",
+  CannotPostpone: "CANNOT_POSTPONE",
+  CapabilityUnavailable: "CAPABILITY_UNAVAILABLE",
+  ConflictVersion: "CONFLICT_VERSION",
+  FileOrphaned: "FILE_ORPHANED",
+  FilePurged: "FILE_PURGED",
+  IdempotencyKeyReused: "IDEMPOTENCY_KEY_REUSED",
+  InternalError: "INTERNAL_ERROR",
+  Locked: "LOCKED",
+  NotATrek: "NOT_A_TREK",
+  NotImplemented: "NOT_IMPLEMENTED",
+  OutOfTripWindow: "OUT_OF_TRIP_WINDOW",
+  PlanFeatureDisabled: "PLAN_FEATURE_DISABLED",
+  RateLimited: "RATE_LIMITED",
+  ReadOnlyRole: "READ_ONLY_ROLE",
+  ResourceNotFound: "RESOURCE_NOT_FOUND",
+  ResponseClosed: "RESPONSE_CLOSED",
+  SeatingCapacityOrphan: "SEATING_CAPACITY_ORPHAN",
+  SecretNotReplayable: "SECRET_NOT_REPLAYABLE",
+  ShareTokenExpired: "SHARE_TOKEN_EXPIRED",
+  ShareTokenRevoked: "SHARE_TOKEN_REVOKED",
+  StayWindowHasAssignments: "STAY_WINDOW_HAS_ASSIGNMENTS",
+  StayWindowOverlap: "STAY_WINDOW_OVERLAP",
+  StopHasPending: "STOP_HAS_PENDING",
+  SubjectRequired: "SUBJECT_REQUIRED",
+  TenantScopeMissing: "TENANT_SCOPE_MISSING",
+  Unauthenticated: "UNAUTHENTICATED",
+  UploadMismatch: "UPLOAD_MISMATCH",
+  ValidationError: "VALIDATION_ERROR"
+};
+var Retryability = {
+  No: "no",
+  Yes: "yes",
+  AfterRefresh: "after-refresh",
+  HonourRetryAfter: "honour-retry-after"
+};
+var OutboxClass = {
+  Transient: "TRANSIENT",
+  Conflict: "CONFLICT",
+  Fatal: "FATAL"
+};
+var ERROR_CODE_TABLE = {
+  BUSINESS_RULE_VIOLATION: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  CANNOT_POSTPONE: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  CAPABILITY_UNAVAILABLE: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  CONFLICT_VERSION: { status: 409, retryability: "no", outboxClass: "CONFLICT" },
+  FILE_ORPHANED: { status: 409, retryability: "no", outboxClass: "FATAL" },
+  FILE_PURGED: { status: 410, retryability: "no", outboxClass: "FATAL" },
+  IDEMPOTENCY_KEY_REUSED: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  INTERNAL_ERROR: { status: 500, retryability: "yes", outboxClass: "TRANSIENT" },
+  LOCKED: { status: 423, retryability: "no", outboxClass: "FATAL" },
+  NOT_A_TREK: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  NOT_IMPLEMENTED: { status: 501, retryability: "no", outboxClass: "FATAL" },
+  OUT_OF_TRIP_WINDOW: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  PLAN_FEATURE_DISABLED: { status: 402, retryability: "no", outboxClass: "FATAL" },
+  RATE_LIMITED: { status: 429, retryability: "honour-retry-after", outboxClass: "TRANSIENT" },
+  READ_ONLY_ROLE: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  RESOURCE_NOT_FOUND: { status: 404, retryability: "no", outboxClass: "FATAL" },
+  RESPONSE_CLOSED: { status: 409, retryability: "no", outboxClass: "FATAL" },
+  SEATING_CAPACITY_ORPHAN: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  SECRET_NOT_REPLAYABLE: { status: 409, retryability: "no", outboxClass: "CONFLICT" },
+  SHARE_TOKEN_EXPIRED: { status: 401, retryability: "no", outboxClass: "FATAL" },
+  SHARE_TOKEN_REVOKED: { status: 401, retryability: "no", outboxClass: "FATAL" },
+  STAY_WINDOW_HAS_ASSIGNMENTS: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  STAY_WINDOW_OVERLAP: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  STOP_HAS_PENDING: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  SUBJECT_REQUIRED: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  TENANT_SCOPE_MISSING: { status: 500, retryability: "yes", outboxClass: "TRANSIENT" },
+  UNAUTHENTICATED: { status: 401, retryability: "after-refresh", outboxClass: "FATAL" },
+  UPLOAD_MISMATCH: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  VALIDATION_ERROR: { status: 422, retryability: "no", outboxClass: "FATAL" }
+};
+
+// src/http/errors.ts
+var KaafilError = class extends Error {
+  code;
+  status;
+  details;
+  requestId;
+  meta;
+  constructor(message, init = {}) {
+    super(message, init.cause !== void 0 ? { cause: init.cause } : void 0);
+    this.name = "KaafilError";
+    this.code = init.code;
+    this.status = init.status;
+    this.details = init.details;
+    this.requestId = init.requestId;
+    this.meta = init.meta;
+  }
+};
+var KaafilApiError = class _KaafilApiError extends KaafilError {
+  kind = "api";
+  code;
+  constructor(code, message, init = {}) {
+    super(message, { ...init, code });
+    this.name = "KaafilApiError";
+    this.code = code;
+    Object.setPrototypeOf(this, _KaafilApiError.prototype);
+  }
+};
+var KaafilNotFoundError = class _KaafilNotFoundError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.ResourceNotFound, message, init);
+    this.name = "KaafilNotFoundError";
+    this.code = KaafilErrorCode.ResourceNotFound;
+    Object.setPrototypeOf(this, _KaafilNotFoundError.prototype);
+  }
+};
+var KaafilEntitlementError = class _KaafilEntitlementError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.PlanFeatureDisabled, message, init);
+    this.name = "KaafilEntitlementError";
+    this.code = KaafilErrorCode.PlanFeatureDisabled;
+    Object.setPrototypeOf(this, _KaafilEntitlementError.prototype);
+  }
+  /**
+   * `details.reason` — which of three different people can fix this. Read
+   * defensively, like `.fields`/`.currentVersion` below: `details` is
+   * untyped at the transport boundary, so a value this SDK does not
+   * recognise (an engine that ships a fourth reason before this SDK knows
+   * about it) surfaces as `undefined` rather than a wrong branch.
+   */
+  get reason() {
+    const value = this.details?.reason;
+    return value === "agencyFlag" || value === "partnerTier" || value === "tripQuota" ? value : void 0;
+  }
+};
+var KaafilCapabilityUnavailableError = class _KaafilCapabilityUnavailableError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.CapabilityUnavailable, message, init);
+    this.name = "KaafilCapabilityUnavailableError";
+    this.code = KaafilErrorCode.CapabilityUnavailable;
+    Object.setPrototypeOf(this, _KaafilCapabilityUnavailableError.prototype);
+  }
+};
+var KaafilReadOnlyRoleError = class _KaafilReadOnlyRoleError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.ReadOnlyRole, message, init);
+    this.name = "KaafilReadOnlyRoleError";
+    this.code = KaafilErrorCode.ReadOnlyRole;
+    Object.setPrototypeOf(this, _KaafilReadOnlyRoleError.prototype);
+  }
+};
+var KaafilValidationError = class _KaafilValidationError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.ValidationError, message, init);
+    this.name = "KaafilValidationError";
+    this.code = KaafilErrorCode.ValidationError;
+    Object.setPrototypeOf(this, _KaafilValidationError.prototype);
+  }
+  get fields() {
+    const value = this.details?.fields;
+    return typeof value === "object" && value !== null ? value : void 0;
+  }
+};
+var KaafilVersionConflictError = class _KaafilVersionConflictError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.ConflictVersion, message, init);
+    this.name = "KaafilVersionConflictError";
+    this.code = KaafilErrorCode.ConflictVersion;
+    Object.setPrototypeOf(this, _KaafilVersionConflictError.prototype);
+  }
+  get currentVersion() {
+    const value = this.details?.currentVersion;
+    return typeof value === "number" ? value : void 0;
+  }
+};
+var KaafilLockedError = class _KaafilLockedError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.Locked, message, init);
+    this.name = "KaafilLockedError";
+    this.code = KaafilErrorCode.Locked;
+    Object.setPrototypeOf(this, _KaafilLockedError.prototype);
+  }
+};
+var KaafilRateLimitedError = class _KaafilRateLimitedError extends KaafilApiError {
+  code;
+  retryAfterSeconds;
+  constructor(message, init = {}) {
+    const { retryAfterSeconds, ...rest } = init;
+    super(KaafilErrorCode.RateLimited, message, rest);
+    this.name = "KaafilRateLimitedError";
+    this.code = KaafilErrorCode.RateLimited;
+    this.retryAfterSeconds = retryAfterSeconds;
+    Object.setPrototypeOf(this, _KaafilRateLimitedError.prototype);
+  }
+};
+var KaafilUnauthenticatedError = class _KaafilUnauthenticatedError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.Unauthenticated, message, init);
+    this.name = "KaafilUnauthenticatedError";
+    this.code = KaafilErrorCode.Unauthenticated;
+    Object.setPrototypeOf(this, _KaafilUnauthenticatedError.prototype);
+  }
+};
+var KaafilShareTokenExpiredError = class _KaafilShareTokenExpiredError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.ShareTokenExpired, message, init);
+    this.name = "KaafilShareTokenExpiredError";
+    this.code = KaafilErrorCode.ShareTokenExpired;
+    Object.setPrototypeOf(this, _KaafilShareTokenExpiredError.prototype);
+  }
+};
+var KaafilShareTokenRevokedError = class _KaafilShareTokenRevokedError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.ShareTokenRevoked, message, init);
+    this.name = "KaafilShareTokenRevokedError";
+    this.code = KaafilErrorCode.ShareTokenRevoked;
+    Object.setPrototypeOf(this, _KaafilShareTokenRevokedError.prototype);
+  }
+};
+var KaafilNotImplementedError = class _KaafilNotImplementedError extends KaafilApiError {
+  code;
+  constructor(message, init = {}) {
+    super(KaafilErrorCode.NotImplemented, message, init);
+    this.name = "KaafilNotImplementedError";
+    this.code = KaafilErrorCode.NotImplemented;
+    Object.setPrototypeOf(this, _KaafilNotImplementedError.prototype);
+  }
+};
+var KaafilTransportError = class extends KaafilError {
+  kind = "transport";
+  code;
+  constructor(message, init = {}) {
+    super(message, init);
+    this.code = void 0;
+  }
+};
+var KaafilTimeoutError = class _KaafilTimeoutError extends KaafilTransportError {
+  constructor(message = "Request timed out", init = {}) {
+    super(message, init);
+    this.name = "KaafilTimeoutError";
+    Object.setPrototypeOf(this, _KaafilTimeoutError.prototype);
+  }
+};
+var KaafilAbortError = class _KaafilAbortError extends KaafilTransportError {
+  constructor(message = "Request aborted", init = {}) {
+    super(message, init);
+    this.name = "KaafilAbortError";
+    Object.setPrototypeOf(this, _KaafilAbortError.prototype);
+  }
+};
+var KaafilNetworkError = class _KaafilNetworkError extends KaafilTransportError {
+  constructor(message = "Network request failed", init = {}) {
+    super(message, init);
+    this.name = "KaafilNetworkError";
+    Object.setPrototypeOf(this, _KaafilNetworkError.prototype);
+  }
+};
+var KaafilInvalidRequestError = class _KaafilInvalidRequestError extends KaafilTransportError {
+  constructor(message, init = {}) {
+    super(message, init);
+    this.name = "KaafilInvalidRequestError";
+    Object.setPrototypeOf(this, _KaafilInvalidRequestError.prototype);
+  }
+};
+function isKaafilError(error) {
+  if (error instanceof KaafilError) {
+    return true;
+  }
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const candidate = error;
+  return (candidate.kind === "api" || candidate.kind === "transport") && typeof candidate.message === "string";
+}
+var RETRYABLE_CODES = new Set(
+  Object.keys(ERROR_CODE_TABLE).filter(
+    (code) => ERROR_CODE_TABLE[code].retryability !== Retryability.No
+  )
+);
+function isRetryable(error) {
+  if (!isKaafilError(error)) {
+    return false;
+  }
+  if (error.kind === "transport") {
+    return !(error instanceof KaafilAbortError) && !(error instanceof KaafilInvalidRequestError);
+  }
+  return error.code !== void 0 && RETRYABLE_CODES.has(error.code);
+}
+var KAAFIL_ERROR_CODE_VALUES = new Set(Object.values(KaafilErrorCode));
+function isKaafilErrorCode(value) {
+  return KAAFIL_ERROR_CODE_VALUES.has(value);
+}
+function parseErrorEnvelope(body) {
+  if (typeof body !== "object" || body === null) {
+    return void 0;
+  }
+  const errorField = body.error;
+  if (typeof errorField !== "object" || errorField === null) {
+    return void 0;
+  }
+  const errorRecord = errorField;
+  const code = errorRecord.code;
+  const message = errorRecord.message;
+  if (typeof code !== "string" || !isKaafilErrorCode(code) || typeof message !== "string") {
+    return void 0;
+  }
+  const details = errorRecord.details;
+  return {
+    code,
+    message,
+    details: typeof details === "object" && details !== null ? details : void 0
+  };
+}
+function buildApiErrorInit(init, details) {
+  return {
+    status: init.status,
+    ...details !== void 0 ? { details } : {},
+    ...init.requestId !== void 0 ? { requestId: init.requestId } : {},
+    ...init.meta !== void 0 ? { meta: init.meta } : {},
+    ...init.cause !== void 0 ? { cause: init.cause } : {}
+  };
+}
+function fromEnvelope(body, init) {
+  const parsed = parseErrorEnvelope(body);
+  if (parsed === void 0) {
+    return new KaafilNetworkError(
+      `Received an unrecognizable error body for HTTP ${init.status}`,
+      buildApiErrorInit(init, void 0)
+    );
+  }
+  const commonInit = buildApiErrorInit(init, parsed.details);
+  switch (parsed.code) {
+    case KaafilErrorCode.ResourceNotFound:
+      return new KaafilNotFoundError(parsed.message, commonInit);
+    case KaafilErrorCode.PlanFeatureDisabled:
+      return new KaafilEntitlementError(parsed.message, commonInit);
+    case KaafilErrorCode.CapabilityUnavailable:
+      return new KaafilCapabilityUnavailableError(parsed.message, commonInit);
+    case KaafilErrorCode.ReadOnlyRole:
+      return new KaafilReadOnlyRoleError(parsed.message, commonInit);
+    case KaafilErrorCode.ValidationError:
+      return new KaafilValidationError(parsed.message, commonInit);
+    case KaafilErrorCode.ConflictVersion:
+      return new KaafilVersionConflictError(parsed.message, commonInit);
+    case KaafilErrorCode.Locked:
+      return new KaafilLockedError(parsed.message, commonInit);
+    case KaafilErrorCode.RateLimited:
+      return new KaafilRateLimitedError(parsed.message, {
+        ...commonInit,
+        ...init.retryAfterSeconds !== void 0 ? { retryAfterSeconds: init.retryAfterSeconds } : {}
+      });
+    case KaafilErrorCode.Unauthenticated:
+      return new KaafilUnauthenticatedError(parsed.message, commonInit);
+    case KaafilErrorCode.ShareTokenExpired:
+      return new KaafilShareTokenExpiredError(parsed.message, commonInit);
+    case KaafilErrorCode.ShareTokenRevoked:
+      return new KaafilShareTokenRevokedError(parsed.message, commonInit);
+    case KaafilErrorCode.NotImplemented:
+      return new KaafilNotImplementedError(parsed.message, commonInit);
+    default:
+      return new KaafilApiError(parsed.code, parsed.message, commonInit);
+  }
+}
+
+// src/auth/credentials.ts
+async function resolveValue(value) {
+  return typeof value === "function" ? await value() : value;
+}
+var CredentialKind = {
+  AgencyAdmin: "agencyAdmin",
+  ApiKey: "apiKey",
+  ManagerSession: "managerSession",
+  ShareToken: "shareToken"
+};
+var ROTATING_ACCESS_TOKEN_REFRESH_SKEW_MS = 3e4;
+function isRotatingCredentialKind(kind) {
+  return kind === CredentialKind.AgencyAdmin || kind === CredentialKind.ManagerSession;
+}
+function isRotatingConfig(config) {
+  return isRotatingCredentialKind(config.kind);
+}
+var CREDENTIAL_KIND_SCHEME = {
+  agencyAdmin: SecuritySchemeId.AgencyAdminAuth,
+  apiKey: SecuritySchemeId.ApiKeyAuth,
+  managerSession: SecuritySchemeId.ManagerAuth,
+  shareToken: SecuritySchemeId.ShareAuth
+};
+var UnsatisfiableSchemeError = class _UnsatisfiableSchemeError extends KaafilInvalidRequestError {
+  operationId;
+  acceptedSchemes;
+  credentialKind;
+  constructor(operationId, acceptedSchemes, credentialKind) {
+    const schemeList = acceptedSchemes.length > 0 ? acceptedSchemes.join(", ") : "(no scheme declared)";
+    super(
+      `"${operationId}" accepts [${schemeList}], but the configured "${credentialKind}" credential cannot satisfy any of them.`
+    );
+    this.name = "UnsatisfiableSchemeError";
+    Object.setPrototypeOf(this, _UnsatisfiableSchemeError.prototype);
+    this.operationId = operationId;
+    this.acceptedSchemes = acceptedSchemes;
+    this.credentialKind = credentialKind;
+  }
+};
+function headersForCarrier(schemeId, value) {
+  const carrier = SECURITY_SCHEME_CARRIERS[schemeId];
+  switch (carrier.kind) {
+    case "header":
+      return { [carrier.headerName]: value };
+    case "bearer":
+      return { Authorization: `Bearer ${value}` };
+    case "cookie":
+      throw new Error(`Scheme "${schemeId}" is cookie-borne and has no SDK-side credential kind.`);
+  }
+}
+function createInitialState(config) {
+  return {
+    rotating: isRotatingCredentialKind(config.kind) ? { current: null, refreshPromise: null } : null
+  };
+}
+function isExpiringSoon(expiresAt, nowMs) {
+  if (expiresAt === void 0) {
+    return false;
+  }
+  const expiryMs = Date.parse(expiresAt);
+  if (Number.isNaN(expiryMs)) {
+    return false;
+  }
+  return expiryMs - nowMs <= ROTATING_ACCESS_TOKEN_REFRESH_SKEW_MS;
+}
+var CredentialResolver = class {
+  config;
+  state;
+  /**
+   * The default exchange for a rotating (`managerSession`/`agencyAdmin`)
+   * credential — `undefined` for the two non-rotating kinds, and for a
+   * rotating config that always uses its own `refresh` override instead.
+   * See `RotatingSessionExchange`'s doc comment for why this arrives as a
+   * constructor argument rather than an import.
+   */
+  rotatingSessionExchange;
+  constructor(config, rotatingSessionExchange) {
+    this.config = config;
+    this.state = createInitialState(config);
+    this.rotatingSessionExchange = rotatingSessionExchange;
+  }
+  get kind() {
+    return this.config.kind;
+  }
+  /**
+   * Picks the first scheme in `acceptedSchemes` (spec declaration order)
+   * the configured credential can satisfy and returns its headers. Throws
+   * `UnsatisfiableSchemeError` — never makes the doomed round trip — if
+   * none match. An empty `acceptedSchemes` (a public operation) needs no
+   * credential and returns no headers.
+   */
+  async resolveHeaders(operationId, acceptedSchemes) {
+    if (acceptedSchemes.length === 0) {
+      return { schemeId: null, headers: {} };
+    }
+    const config = this.config;
+    const mySchemeId = CREDENTIAL_KIND_SCHEME[config.kind];
+    if (!acceptedSchemes.includes(mySchemeId)) {
+      throw new UnsatisfiableSchemeError(operationId, acceptedSchemes, config.kind);
+    }
+    const value = await this.currentValue(config);
+    return { schemeId: mySchemeId, headers: headersForCarrier(mySchemeId, value) };
+  }
+  async currentValue(config) {
+    switch (config.kind) {
+      case CredentialKind.ApiKey:
+        return resolveValue(config.apiKey);
+      case CredentialKind.ShareToken:
+        return resolveValue(config.token);
+      case CredentialKind.ManagerSession:
+      case CredentialKind.AgencyAdmin:
+        return this.currentRotatingAccessToken(config);
+    }
+  }
+  async currentRotatingAccessToken(config) {
+    const state = this.rotatingSessionState();
+    if (!state.current) {
+      const [accessToken, refreshToken, expiresAt] = await Promise.all([
+        resolveValue(config.accessToken),
+        resolveValue(config.refreshToken),
+        config.expiresAt !== void 0 ? resolveValue(config.expiresAt) : Promise.resolve(void 0)
+      ]);
+      state.current = { accessToken, refreshToken, expiresAt };
+    }
+    if (isExpiringSoon(state.current.expiresAt, Date.now())) {
+      const result = await this.refreshRotatingSession();
+      return result.accessToken;
+    }
+    return state.current.accessToken;
+  }
+  /**
+   * Single-flight refresh: concurrent triggers (N simultaneous `401`s, or a
+   * pre-emptive check racing a `401`) share one in-flight promise, so the
+   * rotating refresh token is presented exactly once. The promise is
+   * cleared on both success and failure — a rejected refresh never stays
+   * sticky, and the next trigger always starts a fresh exchange
+   * (`architecture/03-auth-and-tokens.md §2`). Callers make one attempt per
+   * request and surface the failure; this method does not loop. Shared by
+   * both rotating kinds — see the module header's argument for why this is
+   * one implementation, not one per kind.
+   */
+  async refreshRotatingSession() {
+    const config = this.config;
+    if (!isRotatingConfig(config)) {
+      throw new Error(
+        'refreshRotatingSession() is only valid for a rotating ("managerSession" or "agencyAdmin") credential.'
+      );
+    }
+    const state = this.rotatingSessionState();
+    if (state.refreshPromise) {
+      return state.refreshPromise;
+    }
+    const promise = this.performRotatingRefresh(config, state);
+    state.refreshPromise = promise;
+    try {
+      return await promise;
+    } finally {
+      state.refreshPromise = null;
+    }
+  }
+  async performRotatingRefresh(config, state) {
+    const refreshToken = state.current?.refreshToken ?? await resolveValue(config.refreshToken);
+    const result = config.refresh !== void 0 ? await config.refresh(refreshToken) : await this.defaultRotatingRefresh(config, state, refreshToken);
+    state.current = {
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresAt: result.expiresAt
+    };
+    await config.onRefresh?.(result);
+    return result;
+  }
+  async defaultRotatingRefresh(config, state, refreshToken) {
+    if (this.rotatingSessionExchange === void 0) {
+      throw new Error(
+        'invariant: a rotating credential without a "refresh" override needs the exchange function the entry point constructs it with \u2014 see "./client-entry.ts".'
+      );
+    }
+    const accessToken = state.current?.accessToken ?? await resolveValue(config.accessToken);
+    return this.rotatingSessionExchange(accessToken, refreshToken);
+  }
+  rotatingSessionState() {
+    const state = this.state.rotating;
+    if (!state) {
+      throw new Error("invariant: rotating-session state missing for a rotating credential.");
+    }
+    return state;
+  }
+  /**
+   * Resets every piece of per-session state in one assignment — teardown
+   * that cannot forget a field because the state is rebuilt from scratch,
+   * not cleared field by field.
+   */
+  reset() {
+    this.state = createInitialState(this.config);
+  }
+};
+
+// src/config.ts
+var ENVIRONMENT_BASE_URLS = {
+  live: "https://api.kaafil.com",
+  test: "https://api.test.kaafil.com"
+};
+var KaafilConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KaafilConfigError";
+  }
+};
+function isValidAbsoluteUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function resolveBaseUrl(environment, baseUrl) {
+  if (baseUrl === void 0) {
+    return ENVIRONMENT_BASE_URLS[environment];
+  }
+  if (!isValidAbsoluteUrl(baseUrl)) {
+    throw new KaafilConfigError(
+      `"baseUrl" must be an absolute http(s) URL; received "${baseUrl}".`
+    );
+  }
+  return baseUrl;
+}
+function assertValidTimeout(timeoutMs) {
+  if (timeoutMs === void 0) {
+    return;
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new KaafilConfigError(`"timeoutMs" must be a positive number; received ${timeoutMs}.`);
+  }
+}
+function assertValidMaxAttempts(maxAttempts) {
+  if (maxAttempts === void 0) {
+    return;
+  }
+  if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) {
+    throw new KaafilConfigError(
+      `"maxAttempts" must be a positive integer; received ${maxAttempts}.`
+    );
+  }
+}
+
+// src/http/retry.ts
+var RETRY_LADDER_MS = [1e3, 5e3, 15e3, 6e4, 3e5, 9e5, 36e5];
+var DEFAULT_MAX_ATTEMPTS = 24;
+function isRetryableFailure(input) {
+  if (input.status === null) {
+    return true;
+  }
+  const entry = input.code !== void 0 ? ERROR_CODE_TABLE[input.code] : void 0;
+  if (entry !== void 0) {
+    return entry.retryability === Retryability.Yes || entry.retryability === Retryability.HonourRetryAfter;
+  }
+  return input.status === 429 || input.status >= 500 && input.status <= 599;
+}
+function computeRetryDelayMs(attempt, options = {}) {
+  if (options.retryAfterSeconds !== void 0) {
+    return Math.max(1, Math.floor(options.retryAfterSeconds)) * 1e3;
+  }
+  const index = Math.min(Math.max(attempt - 1, 0), RETRY_LADDER_MS.length - 1);
+  const base = RETRY_LADDER_MS[index];
+  if (base === void 0) {
+    throw new Error("unreachable: index is clamped to RETRY_LADDER_MS bounds");
+  }
+  const random = options.random ?? Math.random;
+  const half = base / 2;
+  return Math.floor(half + random() * half);
+}
+function delayWithAbort(ms, signal) {
+  if (signal?.aborted === true) {
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var RetryExhaustedError = class extends Error {
+  failure;
+  attempts;
+  constructor(failure, attempts) {
+    super(`retry exhausted after ${attempts} attempt(s), last status ${String(failure.status)}`);
+    this.name = "RetryExhaustedError";
+    this.failure = failure;
+    this.attempts = attempts;
+  }
+};
+async function executeWithRetry(attempt, options = {}) {
+  const unsafeToReplay = options.hasBody === true && options.idempotencyKey === void 0;
+  const maxAttempts = unsafeToReplay ? 1 : options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const random = options.random ?? Math.random;
+  for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
+    if (options.signal?.aborted === true) {
+      throw options.signal.reason;
+    }
+    const outcome = await attempt(attemptNumber);
+    if (outcome.ok) {
+      return outcome.value;
+    }
+    const retryable = isRetryableFailure(outcome);
+    if (!retryable || attemptNumber === maxAttempts) {
+      throw new RetryExhaustedError(outcome, attemptNumber);
+    }
+    const delayMs = computeRetryDelayMs(attemptNumber, {
+      ...outcome.retryAfterSeconds !== void 0 ? { retryAfterSeconds: outcome.retryAfterSeconds } : {},
+      random
+    });
+    await delayWithAbort(delayMs, options.signal);
+  }
+  throw new Error("unreachable: executeWithRetry loop exited without returning or throwing");
+}
+
+// src/http/client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function createHttpClient(config) {
+  const ctx = {
+    baseUrl: config.baseUrl,
+    credentials: config.credentials,
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxAttempts: config.maxAttempts,
+    userAgent: config.userAgent,
+    random: config.random
+  };
+  return {
+    execute: (request) => execute(ctx, request)
+  };
+}
+function renderPath(template, params) {
+  return template.replace(/\{([^}]+)\}/g, (_match, name) => {
+    const raw = params?.[name];
+    if (raw === void 0) {
+      throw new KaafilInvalidRequestError(
+        `Missing path parameter "${name}" for "${template}". Pass it in the call's options.`
+      );
+    }
+    return encodeURIComponent(String(raw));
+  });
+}
+function buildUrl(baseUrl, renderedPath, query) {
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const relativePath = renderedPath.startsWith("/") ? renderedPath.slice(1) : renderedPath;
+  const url = new URL(relativePath, normalizedBase);
+  if (query !== void 0) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0) {
+        continue;
+      }
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+}
+var TIMEOUT_REASON = /* @__PURE__ */ Symbol("kaafil-timeout");
+function combineSignals(callerSignal, timeoutMs) {
+  const controller = new AbortController();
+  const cleanupFns = [];
+  if (callerSignal !== void 0) {
+    if (callerSignal.aborted) {
+      controller.abort(callerSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(callerSignal.reason);
+      callerSignal.addEventListener("abort", onAbort, { once: true });
+      cleanupFns.push(() => callerSignal.removeEventListener("abort", onAbort));
+    }
+  }
+  const timer = setTimeout(() => controller.abort(TIMEOUT_REASON), timeoutMs);
+  cleanupFns.push(() => clearTimeout(timer));
+  return {
+    signal: controller.signal,
+    isTimeout: () => controller.signal.reason === TIMEOUT_REASON,
+    cleanup: () => {
+      for (const fn of cleanupFns) {
+        fn();
+      }
+    }
+  };
+}
+async function buildHeaders(ctx, request, idempotencyKey, hasBody) {
+  const acceptedSchemes = OPERATION_SECURITY[request.operationId];
+  const credential = await ctx.credentials.resolveHeaders(request.operationId, acceptedSchemes);
+  const headers = new Headers();
+  headers.set("Accept", "application/json");
+  if (hasBody) {
+    headers.set("Content-Type", "application/json");
+  }
+  for (const [key, value] of Object.entries(credential.headers)) {
+    headers.set(key, value);
+  }
+  if (idempotencyKey !== void 0) {
+    headers.set("Idempotency-Key", idempotencyKey);
+  }
+  if (ctx.userAgent !== void 0) {
+    try {
+      headers.set("User-Agent", ctx.userAgent);
+    } catch {
+    }
+  }
+  if (request.headers !== void 0) {
+    for (const [key, value] of Object.entries(request.headers)) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isSuccessEnvelope(body) {
+  if (typeof body !== "object" || body === null) {
+    return false;
+  }
+  const record = body;
+  if (record.ok !== true) {
+    return false;
+  }
+  if (typeof record.data !== "object" || record.data === null) {
+    return false;
+  }
+  const meta = record.meta;
+  if (typeof meta !== "object" || meta === null) {
+    return false;
+  }
+  return typeof meta.serverTime === "string";
+}
+function buildResponseMeta(status, requestId, meta) {
+  return {
+    status,
+    serverTime: meta.serverTime,
+    requestId,
+    page: meta.page
+  };
+}
+function parseRetryAfterSeconds(headerValue) {
+  if (headerValue === null) {
+    return void 0;
+  }
+  const seconds = Number(headerValue);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds : void 0;
+}
+function attachMeta(data, meta) {
+  return Object.assign(data, { meta });
+}
+function describeCrossOriginSuspect(url) {
+  const loc = globalThis.location;
+  if (typeof loc !== "object" || loc === null) {
+    return void 0;
+  }
+  const origin = loc.origin;
+  if (typeof origin !== "string" || origin === url.origin) {
+    return void 0;
+  }
+  return `Request failed while calling a different origin (${url.origin}) than the page's own origin (${origin}). The most likely cause is that the API has not allowlisted this origin for CORS \u2014 but the browser withholds the actual reason from JavaScript when it blocks a cross-origin response, so the SDK cannot confirm this; a genuine network outage produces the same rejection. If this is unexpected, the fix is server-side: add this origin to the API's CORS allowlist.`;
+}
+async function sendOnce(ctx, request, idempotencyKey) {
+  const hasBody = request.body !== void 0;
+  const renderedPath = renderPath(request.path, request.pathParams);
+  const url = buildUrl(ctx.baseUrl, renderedPath, request.query);
+  const headers = await buildHeaders(ctx, request, idempotencyKey, hasBody);
+  const combined = combineSignals(request.signal, ctx.timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: request.method,
+      headers,
+      signal: combined.signal,
+      ...hasBody ? { body: JSON.stringify(request.body) } : {}
+    });
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    const status = response.status;
+    const text = await response.text();
+    const body = text.length > 0 ? tryParseJson(text) : void 0;
+    if (response.ok) {
+      if (!isSuccessEnvelope(body)) {
+        throw new KaafilNetworkError(`Received an unrecognizable success body for HTTP ${status}`, {
+          status,
+          ...requestId !== void 0 ? { requestId } : {}
+        });
+      }
+      return { data: body.data, meta: buildResponseMeta(status, requestId, body.meta) };
+    }
+    const retryAfterSeconds = parseRetryAfterSeconds(response.headers.get("retry-after"));
+    throw fromEnvelope(body, {
+      status,
+      ...requestId !== void 0 ? { requestId } : {},
+      ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {}
+    });
+  } catch (error) {
+    if (isKaafilError(error)) {
+      throw error;
+    }
+    if (combined.signal.aborted) {
+      if (combined.isTimeout()) {
+        throw new KaafilTimeoutError("Request timed out", { cause: error });
+      }
+      throw new KaafilAbortError("Request aborted", { cause: error });
+    }
+    throw new KaafilNetworkError(describeCrossOriginSuspect(url) ?? "Request failed", {
+      cause: error
+    });
+  } finally {
+    combined.cleanup();
+  }
+}
+var MANAGER_TOKENS_REFRESH_PATH = "/api/v1/auth/manager-tokens/refresh";
+var AGENCY_ADMIN_TOKENS_REFRESH_PATH = "/api/v1/auth/agency-admin-tokens/refresh";
+function createRotatingSessionRefreshExchange(baseUrl, refreshPath, networkErrorMessage) {
+  return async (accessToken, refreshToken) => {
+    const url = buildUrl(baseUrl, refreshPath, void 0);
+    const headers = new Headers({
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`
+    });
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ refreshToken })
+      });
+    } catch (error) {
+      throw new KaafilNetworkError(networkErrorMessage, { cause: error });
+    }
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    const status = response.status;
+    const text = await response.text();
+    const body = text.length > 0 ? tryParseJson(text) : void 0;
+    if (!response.ok) {
+      throw fromEnvelope(body, {
+        status,
+        ...requestId !== void 0 ? { requestId } : {}
+      });
+    }
+    if (!isSuccessEnvelope(body)) {
+      throw new KaafilNetworkError(`Received an unrecognizable success body for HTTP ${status}`, {
+        status,
+        ...requestId !== void 0 ? { requestId } : {}
+      });
+    }
+    return body.data;
+  };
+}
+function createManagerSessionRefreshExchange(baseUrl) {
+  return createRotatingSessionRefreshExchange(
+    baseUrl,
+    MANAGER_TOKENS_REFRESH_PATH,
+    "Manager-session refresh request failed"
+  );
+}
+function createAgencyAdminSessionRefreshExchange(baseUrl) {
+  return createRotatingSessionRefreshExchange(
+    baseUrl,
+    AGENCY_ADMIN_TOKENS_REFRESH_PATH,
+    "Agency-admin session refresh request failed"
+  );
+}
+function toKaafilError(error) {
+  if (isKaafilError(error)) {
+    return error;
+  }
+  return new KaafilNetworkError("Unexpected transport failure", { cause: error });
+}
+function toFailureOutcome(error) {
+  return {
+    ok: false,
+    status: error.status ?? null,
+    ...error.code !== void 0 ? { code: error.code } : {},
+    ...error instanceof KaafilRateLimitedError && error.retryAfterSeconds !== void 0 ? { retryAfterSeconds: error.retryAfterSeconds } : {}
+  };
+}
+async function execute(ctx, request) {
+  const idempotencyKey = OPERATION_ACCEPTS_IDEMPOTENCY_KEY[request.operationId] ? request.idempotencyKey ?? globalThis.crypto.randomUUID() : void 0;
+  let lastError;
+  let refreshAttempted = false;
+  const sendAndClassify = async () => {
+    try {
+      const { data, meta } = await sendOnce(ctx, request, idempotencyKey);
+      return { ok: true, value: attachMeta(data, meta) };
+    } catch (error) {
+      const typed = toKaafilError(error);
+      lastError = typed;
+      return toFailureOutcome(typed);
+    }
+  };
+  const attempt = async (_attemptNumber) => {
+    const outcome = await sendAndClassify();
+    if (outcome.ok) {
+      return outcome;
+    }
+    const canRefresh = !refreshAttempted && outcome.code === KaafilErrorCode.Unauthenticated && isRotatingCredentialKind(ctx.credentials.kind);
+    if (!canRefresh) {
+      return outcome;
+    }
+    refreshAttempted = true;
+    try {
+      await ctx.credentials.refreshRotatingSession();
+    } catch {
+      return outcome;
+    }
+    return sendAndClassify();
+  };
+  renderPath(request.path, request.pathParams);
+  try {
+    return await executeWithRetry(attempt, {
+      ...ctx.maxAttempts !== void 0 ? { maxAttempts: ctx.maxAttempts } : {},
+      ...request.signal !== void 0 ? { signal: request.signal } : {},
+      ...ctx.random !== void 0 ? { random: ctx.random } : {},
+      ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+      hasBody: request.body !== void 0
+    });
+  } catch (error) {
+    if (error instanceof RetryExhaustedError) {
+      throw lastError ?? error;
+    }
+    if (request.signal?.aborted === true) {
+      throw new KaafilAbortError("Request aborted", { cause: lastError ?? error });
+    }
+    throw error;
+  }
+}
+
+// src/idempotency.ts
+function newIdempotencyKey() {
+  return globalThis.crypto.randomUUID();
+}
+
+// src/resources/journey.ts
+var DEFAULT_WAIT_UNTIL_READY_TIMEOUT_MS = 6e4;
+var DEFAULT_WAIT_UNTIL_READY_POLL_INTERVAL_MS = 1e3;
+function createJourneyResource(client) {
+  const resource = {
+    async get(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadJourney,
+        path: "/api/v1/trips/{ref}/journey",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async capabilities(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadJourneyCapabilities,
+        path: "/api/v1/trips/{ref}/journey/capabilities",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async rebuild(options) {
+      const { tripRef, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RebuildJourney,
+        path: "/api/v1/trips/{ref}/journey/rebuild",
+        pathParams: { ref: tripRef },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async runStep(options) {
+      const { tripRef, stepId, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RunJourneyStep,
+        path: "/api/v1/trips/{ref}/journey/steps/{stepId}/run",
+        pathParams: { ref: tripRef, stepId },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async waitUntilReady(options) {
+      const {
+        tripRef,
+        timeoutMs = DEFAULT_WAIT_UNTIL_READY_TIMEOUT_MS,
+        pollIntervalMs = DEFAULT_WAIT_UNTIL_READY_POLL_INTERVAL_MS,
+        signal
+      } = options;
+      const deadlineAt = Date.now() + timeoutMs;
+      for (; ; ) {
+        try {
+          return await resource.get({ tripRef, ...signal !== void 0 ? { signal } : {} });
+        } catch (error) {
+          if (!(error instanceof KaafilNotFoundError)) {
+            throw error;
+          }
+          const remainingMs = deadlineAt - Date.now();
+          if (remainingMs <= 0) {
+            throw new KaafilTimeoutError(
+              `journey.waitUntilReady timed out after ${String(timeoutMs)}ms waiting for trip "${tripRef}" to become ready. The most likely cause is that the background worker that consumes the build queue is not running against this engine.`,
+              { cause: error }
+            );
+          }
+          try {
+            await delayWithAbort(Math.min(pollIntervalMs, remainingMs), signal);
+          } catch (sleepError) {
+            throw new KaafilAbortError("Request aborted", { cause: sleepError });
+          }
+        }
+      }
+    },
+    triggers: {
+      async list(options) {
+        const { agencyRef, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ListJourneyTriggers,
+          path: "/api/v1/agencies/{ref}/journey-triggers",
+          pathParams: { ref: agencyRef },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { agencyRef, key, version, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchJourneyTrigger,
+          path: "/api/v1/agencies/{ref}/journey-triggers/{key}",
+          pathParams: { ref: agencyRef, key },
+          body,
+          headers: { "If-Match": String(version) },
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+  return resource;
+}
+
+// src/resources/vendors.ts
+function createVendorsResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListTripVendors,
+        path: "/api/v1/trips/{ref}/vendors",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/generated/enums.ts
+var BookingStatus = {
+  Confirmed: "CONFIRMED",
+  Tentative: "TENTATIVE",
+  Cancelled: "CANCELLED"
+};
+var ClaimStatusIngest = {
+  Approved: "APPROVED",
+  Paid: "PAID",
+  Rejected: "REJECTED"
+};
+var EventType = {
+  Trip: "TRIP",
+  Trek: "TREK"
+};
+var Gender = {
+  Male: "MALE",
+  Female: "FEMALE",
+  Other: "OTHER",
+  Unknown: "UNKNOWN"
+};
+var ManagerRole = {
+  Manager: "MANAGER",
+  Coordinator: "COORDINATOR"
+};
+var ManifestMode = {
+  Merge: "merge",
+  Replace: "replace"
+};
+var PartyKind = {
+  Family: "FAMILY",
+  Couple: "COUPLE",
+  Friends: "FRIENDS",
+  Corporate: "CORPORATE",
+  Other: "OTHER"
+};
+var TriggerAnchor = {
+  Start: "START",
+  End: "END"
+};
+var TripMode = {
+  Group: "GROUP",
+  Personalized: "PERSONALIZED"
+};
+var TripStatus = {
+  Confirmed: "CONFIRMED",
+  InProgress: "IN_PROGRESS",
+  Completed: "COMPLETED",
+  Postponed: "POSTPONED",
+  Cancelled: "CANCELLED"
+};
+
+// src/pagination/paginator.ts
+var KaafilPaginationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KaafilPaginationError";
+  }
+};
+var KaafilPaginationInFlightError = class _KaafilPaginationInFlightError extends KaafilPaginationError {
+  constructor() {
+    super("next() was called while a previous call on this paginator was still in flight.");
+    this.name = "KaafilPaginationInFlightError";
+    Object.setPrototypeOf(this, _KaafilPaginationInFlightError.prototype);
+  }
+};
+var KaafilPaginationExhaustedError = class _KaafilPaginationExhaustedError extends KaafilPaginationError {
+  constructor() {
+    super("next() was called after this paginator was already exhausted (hasNext is false).");
+    this.name = "KaafilPaginationExhaustedError";
+    Object.setPrototypeOf(this, _KaafilPaginationExhaustedError.prototype);
+  }
+};
+
+// src/client-entry.ts
+function openTokenField(input) {
+  switch (input.kind) {
+    case "managerSession":
+    case "agencyAdmin":
+      return ["accessToken", input.accessToken];
+    case "shareToken":
+      return ["token", input.token];
+  }
+}
+function openKindLabel(kind) {
+  switch (kind) {
+    case "managerSession":
+      return "manager session";
+    case "agencyAdmin":
+      return "agency-admin session";
+    case "shareToken":
+      return "share";
+  }
+}
+function assertOpenTokenPresent(input) {
+  const [field, value] = openTokenField(input);
+  if (typeof value === "function") {
+    return;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw new KaafilConfigError(
+      `"${field}" is required to open a ${openKindLabel(input.kind)} and was missing or empty. Pass the value returned by the mint call.`
+    );
+  }
+}
+var KaafilClientNotOpenError = class _KaafilClientNotOpenError extends Error {
+  constructor() {
+    super(
+      'This KaafilClient has no open session \u2014 call "session.open(...)", "admin.open(...)", or "share.open(...)" before using a resource, or after "close()".'
+    );
+    this.name = "KaafilClientNotOpenError";
+    Object.setPrototypeOf(this, _KaafilClientNotOpenError.prototype);
+  }
+};
+var KaafilClientAlreadyOpenError = class _KaafilClientAlreadyOpenError extends Error {
+  constructor() {
+    super('This KaafilClient already has an open session; call "close()" before opening another.');
+    this.name = "KaafilClientAlreadyOpenError";
+    Object.setPrototypeOf(this, _KaafilClientAlreadyOpenError.prototype);
+  }
+};
+var KaafilClient = class {
+  #config;
+  #state = null;
+  constructor(options) {
+    assertValidTimeout(options.timeoutMs);
+    assertValidMaxAttempts(options.maxAttempts);
+    this.#config = {
+      baseUrl: resolveBaseUrl(options.environment, options.baseUrl),
+      timeoutMs: options.timeoutMs,
+      maxAttempts: options.maxAttempts,
+      userAgent: options.userAgent,
+      random: options.random
+    };
+  }
+  session = {
+    /**
+     * Opens a manager session with the access/refresh pair a server-side
+     * `kaafil.auth.mintManagerToken(...)` call already minted. Rotation
+     * after this point — pre-emptive, and on a `401` — is entirely
+     * automatic: `CredentialResolver` exchanges directly with the engine
+     * (`../auth/credentials.ts`, `../http/client.ts`'s
+     * `createManagerSessionRefreshExchange`). Nothing else is required —
+     * `refresh`/`onRefresh` above are optional hooks, not obligations.
+     */
+    open: (options) => {
+      this.#open({ kind: "managerSession", ...options });
+    }
+  };
+  admin = {
+    /**
+     * Opens an agency-admin session with the access/refresh pair a
+     * server-side `kaafil.auth.mintAgencyAdminToken(...)` call already
+     * minted. Rotation after this point — pre-emptive, and on a `401` — is
+     * entirely automatic, the same way `session.open`'s is:
+     * `CredentialResolver` exchanges directly with the engine
+     * (`../auth/credentials.ts`, `../http/client.ts`'s
+     * `createAgencyAdminSessionRefreshExchange`). Nothing else is required
+     * — `refresh`/`onRefresh` above are optional hooks, not obligations.
+     */
+    open: (options) => {
+      this.#open({ kind: "agencyAdmin", ...options });
+    }
+  };
+  share = {
+    /** Opens a read-only session with a share token minted server-side by
+     * `kaafil.shareTokens.create(...)`. */
+    open: (options) => {
+      this.#open({ kind: "shareToken", ...options });
+    }
+  };
+  get vendors() {
+    return this.#requireState().vendors;
+  }
+  get journey() {
+    return this.#requireState().journey;
+  }
+  /**
+   * Total teardown. One assignment, no field to forget — see
+   * `KaafilClientState` above. Safe to call whether or not a session is
+   * open; calling any resource method afterward throws
+   * `KaafilClientNotOpenError`, and `session.open`/`share.open` can be
+   * called again immediately after.
+   */
+  close() {
+    this.#state = null;
+  }
+  /**
+   * Mints an idempotency key outside the normal per-call flow. Every
+   * mutating method already mints and reuses one automatically
+   * (`../http/client.ts`) — this exists for the rare case of pinning a key
+   * ahead of time, to replay the exact same logical operation across a
+   * process restart.
+   */
+  static newIdempotencyKey() {
+    return newIdempotencyKey();
+  }
+  #open(input) {
+    if (this.#state !== null) {
+      throw new KaafilClientAlreadyOpenError();
+    }
+    assertOpenTokenPresent(input);
+    let credentialConfig;
+    let rotatingSessionExchange;
+    switch (input.kind) {
+      case "managerSession":
+        credentialConfig = {
+          kind: "managerSession",
+          accessToken: input.accessToken,
+          refreshToken: input.refreshToken,
+          ...input.expiresAt !== void 0 ? { expiresAt: input.expiresAt } : {},
+          ...input.refresh !== void 0 ? { refresh: input.refresh } : {},
+          ...input.onRefresh !== void 0 ? { onRefresh: input.onRefresh } : {}
+        };
+        rotatingSessionExchange = createManagerSessionRefreshExchange(this.#config.baseUrl);
+        break;
+      case "agencyAdmin":
+        credentialConfig = {
+          kind: "agencyAdmin",
+          accessToken: input.accessToken,
+          refreshToken: input.refreshToken,
+          ...input.expiresAt !== void 0 ? { expiresAt: input.expiresAt } : {},
+          ...input.refresh !== void 0 ? { refresh: input.refresh } : {},
+          ...input.onRefresh !== void 0 ? { onRefresh: input.onRefresh } : {}
+        };
+        rotatingSessionExchange = createAgencyAdminSessionRefreshExchange(this.#config.baseUrl);
+        break;
+      case "shareToken":
+        credentialConfig = { kind: "shareToken", token: input.token };
+        break;
+    }
+    const credentials = new CredentialResolver(credentialConfig, rotatingSessionExchange);
+    const http = createHttpClient({
+      baseUrl: this.#config.baseUrl,
+      credentials,
+      ...this.#config.timeoutMs !== void 0 ? { timeoutMs: this.#config.timeoutMs } : {},
+      ...this.#config.maxAttempts !== void 0 ? { maxAttempts: this.#config.maxAttempts } : {},
+      ...this.#config.userAgent !== void 0 ? { userAgent: this.#config.userAgent } : {},
+      ...this.#config.random !== void 0 ? { random: this.#config.random } : {}
+    });
+    this.#state = {
+      http,
+      vendors: createVendorsResource(http),
+      journey: createJourneyResource(http)
+    };
+  }
+  #requireState() {
+    if (this.#state === null) {
+      throw new KaafilClientNotOpenError();
+    }
+    return this.#state;
+  }
+};
+
+export { BookingStatus, ClaimStatusIngest, ERROR_CODE_TABLE, EventType, Gender, KaafilAbortError, KaafilApiError, KaafilCapabilityUnavailableError, KaafilClient, KaafilClientAlreadyOpenError, KaafilClientNotOpenError, KaafilEntitlementError, KaafilError, KaafilErrorCode, KaafilInvalidRequestError, KaafilLockedError, KaafilNetworkError, KaafilNotFoundError, KaafilNotImplementedError, KaafilPaginationError, KaafilPaginationExhaustedError, KaafilPaginationInFlightError, KaafilRateLimitedError, KaafilReadOnlyRoleError, KaafilShareTokenExpiredError, KaafilShareTokenRevokedError, KaafilTimeoutError, KaafilTransportError, KaafilUnauthenticatedError, KaafilValidationError, KaafilVersionConflictError, ManagerRole, ManifestMode, OutboxClass, PartyKind, Retryability, TriggerAnchor, TripMode, TripStatus, UnsatisfiableSchemeError, isKaafilError, isRetryable };
+//# sourceMappingURL=client-entry.js.map
+//# sourceMappingURL=client-entry.js.map