kaafil-js 0.1.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,3541 @@
+'use strict';
+
+// 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 = {
+  AddChecklistItem: "addChecklistItem",
+  AddItineraryItem: "addItineraryItem",
+  AdjustFloat: "adjustFloat",
+  AssignManager: "assignManager",
+  AssignPickupTraveller: "assignPickupTraveller",
+  AssignRoomingBed: "assignRoomingBed",
+  AssignSeating: "assignSeating",
+  AutoAssignRooming: "autoAssignRooming",
+  AutoAssignSeating: "autoAssignSeating",
+  BoardPickupTraveller: "boardPickupTraveller",
+  CancelTrip: "cancelTrip",
+  ClaimStatusIngest: "claimStatusIngest",
+  ClosePickupStop: "closePickupStop",
+  ConfirmFileUpload: "confirmFileUpload",
+  CreatePickupStop: "createPickupStop",
+  CreateRoomingRoom: "createRoomingRoom",
+  CreateRoomingStayWindow: "createRoomingStayWindow",
+  CreateSeatingVehicle: "createSeatingVehicle",
+  CreateTrekWalkIn: "createTrekWalkIn",
+  DeleteChecklistItem: "deleteChecklistItem",
+  DeleteItineraryItem: "deleteItineraryItem",
+  DeletePickupStop: "deletePickupStop",
+  DeleteRoomingRoom: "deleteRoomingRoom",
+  DeleteRoomingStayWindow: "deleteRoomingStayWindow",
+  DeleteSeatingVehicle: "deleteSeatingVehicle",
+  GetTrip: "getTrip",
+  IssueFloat: "issueFloat",
+  LinkExpenseReceipt: "linkExpenseReceipt",
+  LinkSeatingManager: "linkSeatingManager",
+  ListChecklistTemplates: "listChecklistTemplates",
+  ListCollections: "listCollections",
+  ListEligibleCollections: "listEligibleCollections",
+  ListEvents: "listEvents",
+  ListExpenses: "listExpenses",
+  ListJourneyTriggers: "listJourneyTriggers",
+  ListPickupStops: "listPickupStops",
+  ListRoomingStayWindows: "listRoomingStayWindows",
+  ListTripVendors: "listTripVendors",
+  ListWebhookDeliveries: "listWebhookDeliveries",
+  LogExpense: "logExpense",
+  MintAgencyAdminTokens: "mintAgencyAdminTokens",
+  MintManagerTokens: "mintManagerTokens",
+  MintShareToken: "mintShareToken",
+  PatchChecklistItem: "patchChecklistItem",
+  PatchItineraryDay: "patchItineraryDay",
+  PatchItineraryItem: "patchItineraryItem",
+  PatchJourneyTrigger: "patchJourneyTrigger",
+  PatchPickupStop: "patchPickupStop",
+  PatchRoomingRoom: "patchRoomingRoom",
+  PatchRoomingStayWindow: "patchRoomingStayWindow",
+  PatchSeatingVehicle: "patchSeatingVehicle",
+  PostponeTrek: "postponeTrek",
+  PullChecklistTemplate: "pullChecklistTemplate",
+  PushBulkTrips: "pushBulkTrips",
+  PushManifest: "pushManifest",
+  PushTripBalances: "pushTripBalances",
+  ReadChecklistAggregate: "readChecklistAggregate",
+  ReadExpense: "readExpense",
+  ReadFile: "readFile",
+  ReadFileUrl: "readFileUrl",
+  ReadFloatLedger: "readFloatLedger",
+  ReadFloatSummary: "readFloatSummary",
+  ReadItinerary: "readItinerary",
+  ReadItineraryChangeLog: "readItineraryChangeLog",
+  ReadJourney: "readJourney",
+  ReadJourneyCapabilities: "readJourneyCapabilities",
+  ReadManifestByPickup: "readManifestByPickup",
+  ReadRoomingBoard: "readRoomingBoard",
+  ReadSeatingBoard: "readSeatingBoard",
+  ReadShareToken: "readShareToken",
+  ReadTrekBoard: "readTrekBoard",
+  ReadTrekWalkInMeta: "readTrekWalkInMeta",
+  ReadWebhookDelivery: "readWebhookDelivery",
+  RebuildJourney: "rebuildJourney",
+  RecordCollection: "recordCollection",
+  RedeliverWebhookDelivery: "redeliverWebhookDelivery",
+  RemoveFromManifest: "removeFromManifest",
+  ReopenPickupStop: "reopenPickupStop",
+  ReorderItineraryItem: "reorderItineraryItem",
+  ReorderPickupStops: "reorderPickupStops",
+  ReplayWebhookEndpoint: "replayWebhookEndpoint",
+  RequestFileUpload: "requestFileUpload",
+  ReturnFloat: "returnFloat",
+  RevokeShareToken: "revokeShareToken",
+  RunJourneyStep: "runJourneyStep",
+  SubmitExpenseClaim: "submitExpenseClaim",
+  ToggleChecklistItem: "toggleChecklistItem",
+  UnassignManager: "unassignManager",
+  UnlinkSeatingManager: "unlinkSeatingManager",
+  UpsertManager: "upsertManager",
+  UpsertTravellerProfile: "upsertTravellerProfile",
+  UpsertTrip: "upsertTrip",
+  VoidCollection: "voidCollection",
+  VoidExpense: "voidExpense",
+  WithdrawExpenseClaim: "withdrawExpenseClaim"
+};
+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 = {
+  Live: "live",
+  Test: "test"
+};
+var ENVIRONMENT_BASE_URLS = {
+  live: "https://api.kaafil.com",
+  test: "https://api.test.kaafil.com"
+};
+var API_KEY_ENVIRONMENT_PREFIX = {
+  live: "kf_live_",
+  test: "kf_test_"
+};
+var KaafilConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KaafilConfigError";
+  }
+};
+var ApiKeyEnvironmentMismatchError = class extends KaafilConfigError {
+  environment;
+  keyPrefix;
+  constructor(environment, apiKey) {
+    const keyPrefix = apiKey.includes("_") ? `${apiKey.split("_").slice(0, 2).join("_")}_` : apiKey;
+    super(
+      `environment: "${environment}" expects an API key prefixed "${API_KEY_ENVIRONMENT_PREFIX[environment]}", but the configured key is prefixed "${keyPrefix}".`
+    );
+    this.name = "ApiKeyEnvironmentMismatchError";
+    this.environment = environment;
+    this.keyPrefix = keyPrefix;
+  }
+};
+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}.`
+    );
+  }
+}
+function assertApiKeyMatchesEnvironment(apiKey, environment) {
+  const expectedPrefix = API_KEY_ENVIRONMENT_PREFIX[environment];
+  const isKnownPrefix = apiKey.startsWith(API_KEY_ENVIRONMENT_PREFIX.live) || apiKey.startsWith(API_KEY_ENVIRONMENT_PREFIX.test);
+  if (!isKnownPrefix) {
+    throw new KaafilConfigError(
+      `"apiKey" does not look like a Kaafil API key (expected a "${API_KEY_ENVIRONMENT_PREFIX.live}" or "${API_KEY_ENVIRONMENT_PREFIX.test}" prefix).`
+    );
+  }
+  if (!apiKey.startsWith(expectedPrefix)) {
+    throw new ApiKeyEnvironmentMismatchError(environment, apiKey);
+  }
+}
+function guardApiKeyEnvironment(apiKey, environment) {
+  if (typeof apiKey !== "function") {
+    assertApiKeyMatchesEnvironment(apiKey, environment);
+    return apiKey;
+  }
+  const resolver = apiKey;
+  return async () => {
+    const value = await resolver();
+    assertApiKeyMatchesEnvironment(value, environment);
+    return value;
+  };
+}
+
+// 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();
+  }
+}
+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/auth.ts
+function createAuthResource(client) {
+  return {
+    async mintManagerToken(options) {
+      const { signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.MintManagerTokens,
+        path: "/api/v1/auth/manager-tokens",
+        body,
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async mintAgencyAdminToken(options) {
+      const { signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.MintAgencyAdminTokens,
+        path: "/api/v1/auth/agency-admin-tokens",
+        body,
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/checklists.ts
+function createChecklistsResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadChecklistAggregate,
+        path: "/api/v1/trips/{ref}/checklist",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    items: {
+      async add(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.AddChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, itemId, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, itemId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async toggle(options) {
+        const { tripRef, itemId, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.ToggleChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items/{itemId}/toggle",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    templates: {
+      async list(options) {
+        const { tripRef, locale, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ListChecklistTemplates,
+          path: "/api/v1/trips/{ref}/checklist/templates",
+          pathParams: { ref: tripRef },
+          query: { locale },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async pull(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.PullChecklistTemplate,
+          path: "/api/v1/trips/{ref}/checklist/pull-template",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/datetime.ts
+var FULL_DATETIME_WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function invalidRequest(fieldPath, message) {
+  return new KaafilInvalidRequestError(`${fieldPath}: ${message}`);
+}
+function normalizeDateTimeInput(value, fieldPath) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw invalidRequest(fieldPath, "received an invalid Date (getTime() is NaN).");
+    }
+    return value.toISOString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw invalidRequest(
+        fieldPath,
+        `received a non-finite number (${String(value)}); expected epoch milliseconds.`
+      );
+    }
+    return new Date(value).toISOString();
+  }
+  if (FULL_DATETIME_WITH_OFFSET.test(value)) {
+    return value;
+  }
+  if (DATE_ONLY.test(value)) {
+    throw invalidRequest(
+      fieldPath,
+      `received a date-only string ("${value}"). This API requires a full ISO-8601 datetime WITH an offset, and the SDK will not guess which timezone you meant (midnight UTC is rarely midnight where the trip actually starts). Pass a \`Date\` instead \u2014 e.g. \`new Date("2026-08-20T09:00:00+05:30")\` \u2014 or add an explicit offset yourself, e.g. "2026-08-20T00:00:00+05:30".`
+    );
+  }
+  throw invalidRequest(
+    fieldPath,
+    `received "${value}", which is not a full ISO-8601 datetime with an offset. Pass a \`Date\`, an epoch-milliseconds number, or a string like "2026-08-20T09:00:00+05:30".`
+  );
+}
+function normalizeNullableDateTimeInput(value, fieldPath) {
+  return value === null ? null : normalizeDateTimeInput(value, fieldPath);
+}
+
+// src/resources/collections.ts
+function createCollectionsResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, travellerId, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListCollections,
+        path: "/api/v1/trips/{ref}/collections",
+        pathParams: { ref: tripRef },
+        query: { travellerId, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async eligible(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListEligibleCollections,
+        path: "/api/v1/trips/{ref}/collections/eligible",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async record(options) {
+      const { tripRef, idempotencyKey, signal, collectedAt, ...rest } = options;
+      const body = {
+        ...rest,
+        ...collectedAt !== void 0 ? { collectedAt: normalizeDateTimeInput(collectedAt, "collectedAt") } : {}
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RecordCollection,
+        path: "/api/v1/trips/{ref}/collections",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async void(options) {
+      const { tripRef, collectionId, version, signal, ...body } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.VoidCollection,
+        path: "/api/v1/trips/{ref}/collections/{id}/void",
+        pathParams: { ref: tripRef, id: collectionId },
+        body,
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// 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);
+  }
+};
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([402, 404, 422]);
+function isTerminalStatus(error) {
+  return typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" && TERMINAL_STATUSES.has(error.status);
+}
+function createInitialState2(filters) {
+  return {
+    cursor: void 0,
+    hasNext: true,
+    isLoading: false,
+    lastError: void 0,
+    meta: void 0,
+    items: [],
+    filters
+  };
+}
+function createPaginator(config) {
+  const { fetchPage, limit } = config;
+  const state = createInitialState2(config.filters);
+  async function next() {
+    if (state.isLoading) {
+      throw new KaafilPaginationInFlightError();
+    }
+    if (!state.hasNext) {
+      throw new KaafilPaginationExhaustedError();
+    }
+    state.isLoading = true;
+    try {
+      const page = await fetchPage({ cursor: state.cursor, limit, filters: state.filters });
+      state.items.push(...page.items);
+      state.cursor = page.meta.page.cursor ?? void 0;
+      state.hasNext = page.meta.page.hasNext;
+      state.meta = page.meta;
+      state.lastError = void 0;
+      return page.items;
+    } catch (error) {
+      state.lastError = error;
+      if (isTerminalStatus(error)) {
+        state.hasNext = false;
+        return [];
+      }
+      throw error;
+    } finally {
+      state.isLoading = false;
+    }
+  }
+  function setFilters(filters) {
+    const fresh = createInitialState2(filters);
+    state.cursor = fresh.cursor;
+    state.hasNext = fresh.hasNext;
+    state.isLoading = fresh.isLoading;
+    state.lastError = fresh.lastError;
+    state.meta = fresh.meta;
+    state.items.length = 0;
+    state.filters = filters;
+  }
+  async function* iterate() {
+    while (state.hasNext) {
+      const page = await next();
+      for (const item of page) {
+        yield item;
+      }
+    }
+  }
+  return {
+    get items() {
+      return state.items;
+    },
+    get hasNext() {
+      return state.hasNext;
+    },
+    get isLoading() {
+      return state.isLoading;
+    },
+    get lastError() {
+      return state.lastError;
+    },
+    get meta() {
+      return state.meta;
+    },
+    next,
+    setFilters,
+    [Symbol.asyncIterator]: iterate
+  };
+}
+
+// src/resources/internal.ts
+function narrowPaged(response) {
+  if (response.meta.page === void 0) {
+    throw new Error("invariant: a cursor-paginated response arrived without meta.page.");
+  }
+  return response;
+}
+function toPaginatorPage(response) {
+  const paged = narrowPaged(response);
+  return { items: paged, meta: paged.meta };
+}
+
+// src/resources/events.ts
+async function fetchEventsPage(client, request) {
+  const response = await client.execute({
+    method: "GET",
+    operationId: OperationId.ListEvents,
+    path: "/api/v1/events",
+    query: { ...request.filters, cursor: request.cursor, limit: request.limit }
+  });
+  return toPaginatorPage(response);
+}
+function createEventsResource(client) {
+  return {
+    list(options = {}) {
+      return createPaginator({
+        fetchPage: (request) => fetchEventsPage(client, request),
+        filters: options.filters ?? {},
+        ...options.limit !== void 0 ? { limit: options.limit } : {}
+      });
+    },
+    async listPage(options = {}) {
+      const { cursor, limit, signal, ...filters } = options;
+      const response = await client.execute({
+        method: "GET",
+        operationId: OperationId.ListEvents,
+        path: "/api/v1/events",
+        query: { ...filters, cursor, limit },
+        ...signal !== void 0 ? { signal } : {}
+      });
+      return narrowPaged(response);
+    }
+  };
+}
+
+// src/resources/expenses.ts
+function createExpensesResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, since, signal, ...filters } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListExpenses,
+        path: "/api/v1/trips/{ref}/expenses",
+        pathParams: { ref: tripRef },
+        query: { ...filters, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async read(options) {
+      const { tripRef, expenseId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadExpense,
+        path: "/api/v1/trips/{ref}/expenses/{id}",
+        pathParams: { ref: tripRef, id: expenseId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async log(options) {
+      const { tripRef, idempotencyKey, signal, spentAt, ...rest } = options;
+      const body = {
+        ...rest,
+        ...spentAt !== void 0 ? { spentAt: normalizeDateTimeInput(spentAt, "spentAt") } : {}
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.LogExpense,
+        path: "/api/v1/trips/{ref}/expenses",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async linkReceipt(options) {
+      const { tripRef, expenseId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "PATCH",
+        operationId: OperationId.LinkExpenseReceipt,
+        path: "/api/v1/trips/{ref}/expenses/{id}/receipt",
+        pathParams: { ref: tripRef, id: expenseId },
+        body,
+        idempotencyKey,
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async void(options) {
+      const { tripRef, expenseId, version, signal, ...body } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.VoidExpense,
+        path: "/api/v1/trips/{ref}/expenses/{id}/void",
+        pathParams: { ref: tripRef, id: expenseId },
+        body,
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    claims: {
+      async submit(options) {
+        const { tripRef, expenseId, idempotencyKey, signal } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.SubmitExpenseClaim,
+          path: "/api/v1/trips/{ref}/expenses/{id}/claim",
+          pathParams: { ref: tripRef, id: expenseId },
+          body: {},
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async withdraw(options) {
+        const { tripRef, expenseId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.WithdrawExpenseClaim,
+          path: "/api/v1/trips/{ref}/expenses/{id}/claim/withdraw",
+          pathParams: { ref: tripRef, id: expenseId },
+          body: {},
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async ingest(options) {
+        const { tripRef, expenseId, idempotencyKey, signal, decisionAt, ...rest } = options;
+        const body = {
+          ...rest,
+          decisionAt: normalizeDateTimeInput(decisionAt, "decisionAt")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.ClaimStatusIngest,
+          path: "/api/v1/trips/{ref}/expenses/{id}/claim-status",
+          pathParams: { ref: tripRef, id: expenseId },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/files.ts
+function createFilesResource(client) {
+  return {
+    async request(options) {
+      const { idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RequestFileUpload,
+        path: "/api/v1/files",
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async meta(options) {
+      const { fileId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFile,
+        path: "/api/v1/files/{id}",
+        pathParams: { id: fileId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async confirm(options) {
+      const { fileId, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ConfirmFileUpload,
+        path: "/api/v1/files/{id}/confirm",
+        pathParams: { id: fileId },
+        body: {},
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async url(options) {
+      const { fileId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFileUrl,
+        path: "/api/v1/files/{id}/url",
+        pathParams: { id: fileId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/float.ts
+function createFloatResource(client) {
+  return {
+    async readSummary(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFloatSummary,
+        path: "/api/v1/trips/{ref}/float",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async readLedger(options) {
+      const { tripRef, managerId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFloatLedger,
+        path: "/api/v1/trips/{ref}/float/{managerId}/ledger",
+        pathParams: { ref: tripRef, managerId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async issue(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.IssueFloat,
+        path: "/api/v1/trips/{ref}/float/issue",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async return(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReturnFloat,
+        path: "/api/v1/trips/{ref}/float/return",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async adjust(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AdjustFloat,
+        path: "/api/v1/trips/{ref}/float/adjust",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/itinerary.ts
+function createItineraryResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, dayIndex, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadItinerary,
+        path: "/api/v1/trips/{ref}/itinerary",
+        pathParams: { ref: tripRef },
+        query: { dayIndex, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    items: {
+      async add(options) {
+        const { tripRef, idempotencyKey, signal, isoDate, startTime, endTime, ...rest } = options;
+        const body = {
+          ...rest,
+          isoDate: normalizeDateTimeInput(isoDate, "isoDate"),
+          ...startTime !== void 0 ? { startTime: normalizeNullableDateTimeInput(startTime, "startTime") } : {},
+          ...endTime !== void 0 ? { endTime: normalizeNullableDateTimeInput(endTime, "endTime") } : {}
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.AddItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, itemId, version, signal, startTime, endTime, ...rest } = options;
+        const body = {
+          ...rest,
+          ...startTime !== void 0 ? { startTime: normalizeNullableDateTimeInput(startTime, "startTime") } : {},
+          ...endTime !== void 0 ? { endTime: normalizeNullableDateTimeInput(endTime, "endTime") } : {}
+        };
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, itemId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async reorder(options) {
+        const { tripRef, itemId, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.ReorderItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items/{itemId}/reorder",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    days: {
+      async patch(options) {
+        const { tripRef, dayIndex, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchItineraryDay,
+          path: "/api/v1/trips/{ref}/itinerary/days/{dayIndex}",
+          pathParams: { ref: tripRef, dayIndex },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    changeLog: {
+      async list(options) {
+        const { tripRef, since, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ReadItineraryChangeLog,
+          path: "/api/v1/trips/{ref}/itinerary/change-log",
+          pathParams: { ref: tripRef },
+          query: { since },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// 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/pickups.ts
+function createPickupsResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, kind, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListPickupStops,
+        path: "/api/v1/trips/{ref}/pickups",
+        pathParams: { ref: tripRef },
+        query: { kind, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async create(options) {
+      const { tripRef, idempotencyKey, signal, scheduledTime, ...rest } = options;
+      const body = {
+        ...rest,
+        scheduledTime: normalizeDateTimeInput(scheduledTime, "scheduledTime")
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.CreatePickupStop,
+        path: "/api/v1/trips/{ref}/pickups",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async patch(options) {
+      const { tripRef, pointId, version, signal, scheduledTime, ...rest } = options;
+      const body = {
+        ...rest,
+        ...scheduledTime !== void 0 ? { scheduledTime: normalizeDateTimeInput(scheduledTime, "scheduledTime") } : {}
+      };
+      return client.execute({
+        method: "PATCH",
+        operationId: OperationId.PatchPickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async remove(options) {
+      const { tripRef, pointId, version, force, signal } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.DeletePickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}",
+        pathParams: { ref: tripRef, pointId },
+        query: { force },
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async reorder(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReorderPickupStops,
+        path: "/api/v1/trips/{ref}/pickups/reorder",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async assign(options) {
+      const { tripRef, pointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AssignPickupTraveller,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/assign",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async board(options) {
+      const { tripRef, pointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.BoardPickupTraveller,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/board",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async close(options) {
+      const { tripRef, pointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ClosePickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/close",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async reopen(options) {
+      const { tripRef, pointId, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReopenPickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/reopen",
+        pathParams: { ref: tripRef, pointId },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async manifestByPickup(options) {
+      const { tripRef, kind, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadManifestByPickup,
+        path: "/api/v1/trips/{ref}/manifest-by-pickup",
+        pathParams: { ref: tripRef },
+        query: { kind },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/rooming.ts
+function createRoomingResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, stayWindowId, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadRoomingBoard,
+        path: "/api/v1/trips/{ref}/rooming",
+        pathParams: { ref: tripRef },
+        query: { stayWindowId, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async assign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AssignRoomingBed,
+        path: "/api/v1/trips/{ref}/rooming/assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async autoAssign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AutoAssignRooming,
+        path: "/api/v1/trips/{ref}/rooming/auto-assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    stayWindows: {
+      async list(options) {
+        const { tripRef, since, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ListRoomingStayWindows,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows",
+          pathParams: { ref: tripRef },
+          query: { since },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async create(options) {
+        const { tripRef, idempotencyKey, signal, startDate, endDate, ...rest } = options;
+        const body = {
+          ...rest,
+          startDate: normalizeDateTimeInput(startDate, "startDate"),
+          endDate: normalizeDateTimeInput(endDate, "endDate")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateRoomingStayWindow,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, windowId, version, signal, startDate, endDate, ...rest } = options;
+        const body = {
+          ...rest,
+          ...startDate !== void 0 ? { startDate: normalizeDateTimeInput(startDate, "startDate") } : {},
+          ...endDate !== void 0 ? { endDate: normalizeDateTimeInput(endDate, "endDate") } : {}
+        };
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchRoomingStayWindow,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows/{windowId}",
+          pathParams: { ref: tripRef, windowId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, windowId, version, force, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteRoomingStayWindow,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows/{windowId}",
+          pathParams: { ref: tripRef, windowId },
+          query: { force },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    rooms: {
+      async create(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateRoomingRoom,
+          path: "/api/v1/trips/{ref}/rooming/rooms",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, roomId, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchRoomingRoom,
+          path: "/api/v1/trips/{ref}/rooming/rooms/{roomId}",
+          pathParams: { ref: tripRef, roomId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, roomId, version, force, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteRoomingRoom,
+          path: "/api/v1/trips/{ref}/rooming/rooms/{roomId}",
+          pathParams: { ref: tripRef, roomId },
+          query: { force },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/seating.ts
+function createSeatingResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadSeatingBoard,
+        path: "/api/v1/trips/{ref}/seating",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async assign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AssignSeating,
+        path: "/api/v1/trips/{ref}/seating/assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async autoAssign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AutoAssignSeating,
+        path: "/api/v1/trips/{ref}/seating/auto-assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    vehicles: {
+      async create(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateSeatingVehicle,
+          path: "/api/v1/trips/{ref}/seating/vehicles",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, vehicleId, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchSeatingVehicle,
+          path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}",
+          pathParams: { ref: tripRef, vehicleId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, vehicleId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteSeatingVehicle,
+          path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}",
+          pathParams: { ref: tripRef, vehicleId },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      manager: {
+        async link(options) {
+          const { tripRef, vehicleId, idempotencyKey, signal, ...body } = options;
+          return client.execute({
+            method: "POST",
+            operationId: OperationId.LinkSeatingManager,
+            path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}/manager",
+            pathParams: { ref: tripRef, vehicleId },
+            body,
+            ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+            ...signal !== void 0 ? { signal } : {}
+          });
+        },
+        async unlink(options) {
+          const { tripRef, vehicleId, version, signal } = options;
+          return client.execute({
+            method: "DELETE",
+            operationId: OperationId.UnlinkSeatingManager,
+            path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}/manager",
+            pathParams: { ref: tripRef, vehicleId },
+            headers: { "If-Match": String(version) },
+            ...signal !== void 0 ? { signal } : {}
+          });
+        }
+      }
+    }
+  };
+}
+
+// src/resources/share-tokens.ts
+function createShareTokensResource(client) {
+  return {
+    async create(options) {
+      const { idempotencyKey, signal, expiresAt, ...rest } = options;
+      const body = {
+        ...rest,
+        ...expiresAt !== void 0 ? { expiresAt: normalizeDateTimeInput(expiresAt, "expiresAt") } : {}
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.MintShareToken,
+        path: "/api/v1/share-tokens",
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async read(options) {
+      const { id, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadShareToken,
+        path: "/api/v1/share-tokens/{id}",
+        pathParams: { id },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async revoke(options) {
+      const { id, signal } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.RevokeShareToken,
+        path: "/api/v1/share-tokens/{id}",
+        pathParams: { id },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/treks.ts
+var ACTIVE_TREK_REF = "active";
+function createTreksResource(client) {
+  return {
+    async board(options) {
+      const { trekRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadTrekBoard,
+        path: "/api/v1/treks/{trekRef}/board",
+        pathParams: { trekRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async postpone(options) {
+      const { trekRef, idempotencyKey, signal, newStartDate, newEndDate, ...rest } = options;
+      const body = {
+        ...rest,
+        newStartDate: normalizeDateTimeInput(newStartDate, "newStartDate"),
+        newEndDate: normalizeDateTimeInput(newEndDate, "newEndDate")
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.PostponeTrek,
+        path: "/api/v1/treks/{trekRef}/postpone",
+        pathParams: { trekRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    walkIns: {
+      async meta(options) {
+        const { trekRef, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ReadTrekWalkInMeta,
+          path: "/api/v1/treks/{trekRef}/walk-ins/meta",
+          pathParams: { trekRef },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async create(options) {
+        const { trekRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateTrekWalkIn,
+          path: "/api/v1/treks/{trekRef}/walk-ins",
+          pathParams: { trekRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/trips.ts
+function normalizeBulkTripsItem(item, tripIndex) {
+  const { startDate, endDate, sourceUpdatedAt, travellers, balance, managers, ...rest } = item;
+  return {
+    ...rest,
+    startDate: normalizeDateTimeInput(startDate, `trips[${tripIndex}].startDate`),
+    endDate: normalizeDateTimeInput(endDate, `trips[${tripIndex}].endDate`),
+    sourceUpdatedAt: normalizeDateTimeInput(sourceUpdatedAt, `trips[${tripIndex}].sourceUpdatedAt`),
+    ...travellers !== void 0 ? {
+      travellers: travellers.map((traveller, index) => ({
+        ...traveller,
+        sourceUpdatedAt: normalizeDateTimeInput(
+          traveller.sourceUpdatedAt,
+          `trips[${tripIndex}].travellers[${index}].sourceUpdatedAt`
+        )
+      }))
+    } : {},
+    ...balance !== void 0 ? {
+      balance: balance.map((row, index) => ({
+        ...row,
+        sourceUpdatedAt: normalizeDateTimeInput(
+          row.sourceUpdatedAt,
+          `trips[${tripIndex}].balance[${index}].sourceUpdatedAt`
+        )
+      }))
+    } : {},
+    ...managers !== void 0 ? {
+      managers: managers.map((manager, index) => ({
+        ...manager,
+        sourceUpdatedAt: normalizeDateTimeInput(
+          manager.sourceUpdatedAt,
+          `trips[${tripIndex}].managers[${index}].sourceUpdatedAt`
+        )
+      }))
+    } : {}
+  };
+}
+function createTripsResource(client) {
+  return {
+    async upsert(options) {
+      const { idempotencyKey, signal, startDate, endDate, sourceUpdatedAt, segments, ...rest } = options;
+      const body = {
+        ...rest,
+        startDate: normalizeDateTimeInput(startDate, "startDate"),
+        endDate: normalizeDateTimeInput(endDate, "endDate"),
+        sourceUpdatedAt: normalizeDateTimeInput(sourceUpdatedAt, "sourceUpdatedAt"),
+        ...segments !== void 0 ? {
+          segments: segments.map((segment, index) => ({
+            ...segment,
+            startDate: normalizeDateTimeInput(
+              segment.startDate,
+              `segments[${index}].startDate`
+            ),
+            endDate: normalizeDateTimeInput(segment.endDate, `segments[${index}].endDate`)
+          }))
+        } : {}
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.UpsertTrip,
+        path: "/api/v1/trips",
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async get(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.GetTrip,
+        path: "/api/v1/trips/{ref}",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async cancel(options) {
+      const { tripRef, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.CancelTrip,
+        path: "/api/v1/trips/{ref}",
+        pathParams: { ref: tripRef },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    travellers: {
+      async upsert(options) {
+        const { travellerRef, idempotencyKey, signal, sourceUpdatedAt, ...rest } = options;
+        const body = {
+          ...rest,
+          sourceUpdatedAt: normalizeDateTimeInput(sourceUpdatedAt, "sourceUpdatedAt")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.UpsertTravellerProfile,
+          path: "/api/v1/travellers/{ref}",
+          pathParams: { ref: travellerRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async pushManifest(options) {
+        const { tripRef, idempotencyKey, signal, travellers, ...rest } = options;
+        const body = {
+          ...rest,
+          travellers: travellers.map((traveller, index) => ({
+            ...traveller,
+            sourceUpdatedAt: normalizeDateTimeInput(
+              traveller.sourceUpdatedAt,
+              `travellers[${index}].sourceUpdatedAt`
+            )
+          }))
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.PushManifest,
+          path: "/api/v1/trips/{ref}/travellers",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, travellerRef, idempotencyKey, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.RemoveFromManifest,
+          path: "/api/v1/trips/{ref}/travellers/{travellerRef}",
+          pathParams: { ref: tripRef, travellerRef },
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    managers: {
+      async upsert(options) {
+        const { idempotencyKey, signal, sourceUpdatedAt, ...rest } = options;
+        const body = {
+          ...rest,
+          sourceUpdatedAt: normalizeDateTimeInput(sourceUpdatedAt, "sourceUpdatedAt")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.UpsertManager,
+          path: "/api/v1/managers",
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async assign(options) {
+        const { tripRef, idempotencyKey, signal, sourceUpdatedAt, ...rest } = options;
+        const body = {
+          ...rest,
+          sourceUpdatedAt: normalizeDateTimeInput(sourceUpdatedAt, "sourceUpdatedAt")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.AssignManager,
+          path: "/api/v1/trips/{ref}/managers",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async unassign(options) {
+        const { tripRef, managerRef, idempotencyKey, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.UnassignManager,
+          path: "/api/v1/trips/{ref}/managers/{managerRef}",
+          pathParams: { ref: tripRef, managerRef },
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    balance: {
+      async push(options) {
+        const { tripRef, balances, idempotencyKey, signal } = options;
+        const body = balances.map((row, index) => ({
+          ...row,
+          sourceUpdatedAt: normalizeDateTimeInput(
+            row.sourceUpdatedAt,
+            `balances[${index}].sourceUpdatedAt`
+          )
+        }));
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.PushTripBalances,
+          path: "/api/v1/trips/{ref}/balance",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    bulk: {
+      async push(options) {
+        const { trips, idempotencyKey, signal } = options;
+        const body = trips.map(
+          (item, index) => normalizeBulkTripsItem(item, index)
+        );
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.PushBulkTrips,
+          path: "/api/v1/bulk/trips",
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// 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/resources/webhooks.ts
+async function fetchDeliveriesPage(client, request) {
+  const response = await client.execute({
+    method: "GET",
+    operationId: OperationId.ListWebhookDeliveries,
+    path: "/api/v1/webhooks/deliveries",
+    query: { ...request.filters, cursor: request.cursor, limit: request.limit }
+  });
+  return toPaginatorPage(response);
+}
+function createWebhooksResource(client) {
+  return {
+    deliveries: {
+      list(options = {}) {
+        return createPaginator({
+          fetchPage: (request) => fetchDeliveriesPage(client, request),
+          filters: options.filters ?? {},
+          ...options.limit !== void 0 ? { limit: options.limit } : {}
+        });
+      },
+      async listPage(options = {}) {
+        const { cursor, limit, signal, ...filters } = options;
+        const response = await client.execute({
+          method: "GET",
+          operationId: OperationId.ListWebhookDeliveries,
+          path: "/api/v1/webhooks/deliveries",
+          query: { ...filters, cursor, limit },
+          ...signal !== void 0 ? { signal } : {}
+        });
+        return narrowPaged(response);
+      },
+      async read(options) {
+        const { id, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ReadWebhookDelivery,
+          path: "/api/v1/webhooks/deliveries/{id}",
+          pathParams: { id },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async redeliver(options) {
+        const { id, idempotencyKey, signal } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.RedeliverWebhookDelivery,
+          path: "/api/v1/webhooks/deliveries/{id}/redeliver",
+          pathParams: { id },
+          body: {},
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    async replay(options) {
+      const { endpointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReplayWebhookEndpoint,
+        path: "/api/v1/webhooks/endpoints/{id}/replay",
+        pathParams: { id: endpointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/client.ts
+var KaafilClosedError = class _KaafilClosedError extends Error {
+  constructor() {
+    super("This Kaafil client has been closed; construct a new one to keep making requests.");
+    this.name = "KaafilClosedError";
+    Object.setPrototypeOf(this, _KaafilClosedError.prototype);
+  }
+};
+var Kaafil = class {
+  #state;
+  constructor(options) {
+    assertValidTimeout(options.timeoutMs);
+    assertValidMaxAttempts(options.maxAttempts);
+    const baseUrl = resolveBaseUrl(options.environment, options.baseUrl);
+    const apiKey = guardApiKeyEnvironment(options.apiKey, options.environment);
+    const credentials = new CredentialResolver({ kind: "apiKey", apiKey });
+    const http = createHttpClient({
+      baseUrl,
+      credentials,
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+      ...options.maxAttempts !== void 0 ? { maxAttempts: options.maxAttempts } : {},
+      ...options.userAgent !== void 0 ? { userAgent: options.userAgent } : {},
+      ...options.random !== void 0 ? { random: options.random } : {}
+    });
+    this.#state = {
+      http,
+      auth: createAuthResource(http),
+      shareTokens: createShareTokensResource(http),
+      trips: createTripsResource(http),
+      itinerary: createItineraryResource(http),
+      rooming: createRoomingResource(http),
+      seating: createSeatingResource(http),
+      pickups: createPickupsResource(http),
+      treks: createTreksResource(http),
+      checklists: createChecklistsResource(http),
+      vendors: createVendorsResource(http),
+      journey: createJourneyResource(http),
+      webhooks: createWebhooksResource(http),
+      events: createEventsResource(http),
+      files: createFilesResource(http),
+      collections: createCollectionsResource(http),
+      expenses: createExpensesResource(http),
+      float: createFloatResource(http)
+    };
+  }
+  get auth() {
+    return this.#requireState().auth;
+  }
+  get shareTokens() {
+    return this.#requireState().shareTokens;
+  }
+  get trips() {
+    return this.#requireState().trips;
+  }
+  get itinerary() {
+    return this.#requireState().itinerary;
+  }
+  get rooming() {
+    return this.#requireState().rooming;
+  }
+  get seating() {
+    return this.#requireState().seating;
+  }
+  get pickups() {
+    return this.#requireState().pickups;
+  }
+  get treks() {
+    return this.#requireState().treks;
+  }
+  get checklists() {
+    return this.#requireState().checklists;
+  }
+  get vendors() {
+    return this.#requireState().vendors;
+  }
+  get journey() {
+    return this.#requireState().journey;
+  }
+  get webhooks() {
+    return this.#requireState().webhooks;
+  }
+  get events() {
+    return this.#requireState().events;
+  }
+  get files() {
+    return this.#requireState().files;
+  }
+  get collections() {
+    return this.#requireState().collections;
+  }
+  get expenses() {
+    return this.#requireState().expenses;
+  }
+  get float() {
+    return this.#requireState().float;
+  }
+  /**
+   * Total teardown. One assignment, no field to forget — see `KaafilState`
+   * above. Every subsequent call through any resource getter throws
+   * `KaafilClosedError` instead of quietly continuing to work off a
+   * credential this client no longer considers live.
+   */
+  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();
+  }
+  #requireState() {
+    if (this.#state === null) {
+      throw new KaafilClosedError();
+    }
+    return this.#state;
+  }
+};
+
+// src/delta/cursor.ts
+function isTombstone(row) {
+  return row._tombstone === true;
+}
+function mergeDeltaRows(store, rows) {
+  let added = 0;
+  let updated = 0;
+  let removed = 0;
+  let unchanged = 0;
+  for (const row of rows) {
+    const held = store.get(row.id);
+    if (isTombstone(row)) {
+      if (held === void 0 || held.version > row.version) {
+        unchanged += 1;
+        continue;
+      }
+      store.delete(row.id);
+      removed += 1;
+      continue;
+    }
+    if (held === void 0) {
+      store.set(row.id, row);
+      added += 1;
+      continue;
+    }
+    if (held.version >= row.version) {
+      unchanged += 1;
+      continue;
+    }
+    store.set(row.id, row);
+    updated += 1;
+  }
+  return { added, updated, removed, unchanged };
+}
+var KaafilDeltaCursorInFlightError = class _KaafilDeltaCursorInFlightError extends Error {
+  constructor() {
+    super(
+      "pull() was called while a previous pull on this delta cursor was still in flight. Two concurrent pulls would settle in an unknown order and leave the cursor at whichever response landed last, not the newest \u2014 await the first one's result."
+    );
+    this.name = "KaafilDeltaCursorInFlightError";
+    Object.setPrototypeOf(this, _KaafilDeltaCursorInFlightError.prototype);
+  }
+};
+function createDeltaCursor(config) {
+  const { fetchDelta } = config;
+  const state = {
+    cursor: void 0,
+    isLoading: false
+  };
+  function restore(cursor) {
+    state.cursor = normalizeDateTimeInput(cursor, "cursor");
+  }
+  if (config.cursor !== void 0) {
+    restore(config.cursor);
+  }
+  async function pull(options = {}) {
+    if (state.isLoading) {
+      throw new KaafilDeltaCursorInFlightError();
+    }
+    const previousCursor = state.cursor;
+    state.isLoading = true;
+    try {
+      const response = await fetchDelta({ since: previousCursor, signal: options.signal });
+      state.cursor = response.meta.serverTime;
+      return {
+        data: response,
+        meta: response.meta,
+        cursor: response.meta.serverTime,
+        previousCursor
+      };
+    } finally {
+      state.isLoading = false;
+    }
+  }
+  return {
+    get cursor() {
+      return state.cursor;
+    },
+    get isLoading() {
+      return state.isLoading;
+    },
+    get hasSynced() {
+      return state.cursor !== void 0;
+    },
+    pull,
+    restore,
+    reset() {
+      state.cursor = void 0;
+    }
+  };
+}
+
+// src/generated/enums.ts
+var BoardStatus = {
+  Boarded: "BOARDED",
+  NoShow: "NO_SHOW"
+};
+var BookingStatus = {
+  Confirmed: "CONFIRMED",
+  Tentative: "TENTATIVE",
+  Cancelled: "CANCELLED"
+};
+var ChecklistAudience = {
+  Internal: "INTERNAL",
+  External: "EXTERNAL"
+};
+var ChecklistGate = {
+  None: "NONE",
+  PreToActive: "PRE_TO_ACTIVE",
+  ActiveToClosedOut: "ACTIVE_TO_CLOSED_OUT"
+};
+var ChecklistItemStatus = {
+  Open: "OPEN",
+  Complete: "COMPLETE"
+};
+var ChecklistPhase = {
+  PreDeparture: "PRE_DEPARTURE",
+  InTrip: "IN_TRIP",
+  PostTrip: "POST_TRIP"
+};
+var ChecklistPullTemplateMode = {
+  Append: "append",
+  Replace: "replace"
+};
+var ClaimStatusIngest = {
+  Approved: "APPROVED",
+  Paid: "PAID",
+  Rejected: "REJECTED"
+};
+var CollectionMode = {
+  Cash: "CASH",
+  Upi: "UPI",
+  Card: "CARD",
+  Bank: "BANK"
+};
+var Currency = {
+  Inr: "INR"
+};
+var EventType = {
+  Trip: "TRIP",
+  Trek: "TREK"
+};
+var ExpenseCategory = {
+  Accom: "ACCOM",
+  Food: "FOOD",
+  Transport: "TRANSPORT",
+  Activity: "ACTIVITY",
+  Misc: "MISC"
+};
+var ExpensePaymentMode = {
+  FloatCash: "FLOAT_CASH",
+  Personal: "PERSONAL",
+  Other: "OTHER"
+};
+var FileContentType = {
+  ImageJpeg: "image/jpeg",
+  ImagePng: "image/png",
+  ImageWebp: "image/webp",
+  ImageHeic: "image/heic",
+  ApplicationPdf: "application/pdf"
+};
+var FilePurpose = {
+  ExpenseReceipt: "expense_receipt",
+  FormAttachment: "form_attachment",
+  BookingVoucher: "booking_voucher"
+};
+var FloatDirection = {
+  In: "IN",
+  Out: "OUT"
+};
+var Gender = {
+  Male: "MALE",
+  Female: "FEMALE",
+  Other: "OTHER",
+  Unknown: "UNKNOWN"
+};
+var ItineraryItemStatusUpdate = {
+  Planned: "PLANNED",
+  Completed: "COMPLETED",
+  Skipped: "SKIPPED"
+};
+var ItineraryItemType = {
+  Accommodation: "ACCOMMODATION",
+  Transport: "TRANSPORT",
+  Activity: "ACTIVITY",
+  Meal: "MEAL",
+  Other: "OTHER"
+};
+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 PickupKind = {
+  Pickup: "PICKUP",
+  Drop: "DROP"
+};
+var RoomingFillOrder = {
+  LargestRoomFirst: "LARGEST_ROOM_FIRST",
+  Sequential: "SEQUENTIAL",
+  Balanced: "BALANCED"
+};
+var RoomingGenderPolicy = {
+  StrictSeparate: "STRICT_SEPARATE",
+  GroupMixedOk: "GROUP_MIXED_OK",
+  Off: "OFF"
+};
+var RoomingHeuristicKey = {
+  MedicalFirst: "medicalFirst",
+  Couples: "couples",
+  Parties: "parties",
+  Gender: "gender",
+  Diet: "diet",
+  SpreadSolos: "spreadSolos",
+  PartyGenderPolicy: "partyGenderPolicy",
+  SameBus: "sameBus"
+};
+var RoomType = {
+  Single: "SINGLE",
+  Twin: "TWIN",
+  Shared: "SHARED",
+  Dorm: "DORM"
+};
+var SeatingFillOrder = {
+  Balanced: "BALANCED",
+  FillFirst: "FILL_FIRST",
+  ByStop: "BY_STOP"
+};
+var SeatingGenderAdjacency = {
+  Off: "OFF",
+  AvoidUnrelated: "AVOID_UNRELATED",
+  StrictRows: "STRICT_ROWS"
+};
+var SeatingHeuristicKey = {
+  MedicalFirst: "medicalFirst",
+  Parties: "parties",
+  SameStop: "sameStop",
+  Gender: "gender",
+  BalanceVehicles: "balanceVehicles"
+};
+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"
+};
+var VehicleLayout = {
+  TwoTwo: "TWO_TWO",
+  TwoOne: "TWO_ONE",
+  Flat: "FLAT"
+};
+var VehicleType = {
+  Bus: "BUS",
+  TempoTraveller: "TEMPO_TRAVELLER",
+  Car: "CAR",
+  Flight: "FLIGHT",
+  Train: "TRAIN",
+  Other: "OTHER"
+};
+
+// src/rooming/vocabulary.ts
+var HEURISTIC_SEVERITY = Object.freeze({
+  medicalFirst: "warn",
+  couples: "warn",
+  parties: "split",
+  gender: "never",
+  diet: "info",
+  spreadSolos: "info",
+  partyGenderPolicy: "info",
+  sameBus: "info"
+});
+function isRoomingHeuristicKey(rule) {
+  return Object.hasOwn(HEURISTIC_SEVERITY, rule);
+}
+function roomingHeuristicSeverity(rule) {
+  return isRoomingHeuristicKey(rule) ? HEURISTIC_SEVERITY[rule] : void 0;
+}
+var TONE_FAMILIES = Object.freeze({
+  [Gender.Male]: "male",
+  [Gender.Female]: "female",
+  [Gender.Other]: "other",
+  [Gender.Unknown]: "unknown"
+});
+var UNKNOWN_TONE_FAMILY = TONE_FAMILIES[Gender.Unknown];
+var SHADES_PER_FAMILY = 8;
+var FALLBACK_GLYPH = "?";
+function parseRoomingTone(tone) {
+  const separator = tone.lastIndexOf(".");
+  if (separator <= 0 || separator === tone.length - 1) {
+    return void 0;
+  }
+  const family = tone.slice(0, separator);
+  const rawShade = tone.slice(separator + 1);
+  const shade = Number(rawShade);
+  if (!Number.isInteger(shade) || shade < 0) {
+    return void 0;
+  }
+  return { family, shade };
+}
+
+exports.ACTIVE_TREK_REF = ACTIVE_TREK_REF;
+exports.ApiKeyEnvironmentMismatchError = ApiKeyEnvironmentMismatchError;
+exports.BoardStatus = BoardStatus;
+exports.BookingStatus = BookingStatus;
+exports.ChecklistAudience = ChecklistAudience;
+exports.ChecklistGate = ChecklistGate;
+exports.ChecklistItemStatus = ChecklistItemStatus;
+exports.ChecklistPhase = ChecklistPhase;
+exports.ChecklistPullTemplateMode = ChecklistPullTemplateMode;
+exports.ClaimStatusIngest = ClaimStatusIngest;
+exports.CollectionMode = CollectionMode;
+exports.Currency = Currency;
+exports.ERROR_CODE_TABLE = ERROR_CODE_TABLE;
+exports.Environment = Environment;
+exports.EventType = EventType;
+exports.ExpenseCategory = ExpenseCategory;
+exports.ExpensePaymentMode = ExpensePaymentMode;
+exports.FALLBACK_GLYPH = FALLBACK_GLYPH;
+exports.FileContentType = FileContentType;
+exports.FilePurpose = FilePurpose;
+exports.FloatDirection = FloatDirection;
+exports.Gender = Gender;
+exports.HEURISTIC_SEVERITY = HEURISTIC_SEVERITY;
+exports.ItineraryItemStatusUpdate = ItineraryItemStatusUpdate;
+exports.ItineraryItemType = ItineraryItemType;
+exports.Kaafil = Kaafil;
+exports.KaafilAbortError = KaafilAbortError;
+exports.KaafilApiError = KaafilApiError;
+exports.KaafilCapabilityUnavailableError = KaafilCapabilityUnavailableError;
+exports.KaafilClosedError = KaafilClosedError;
+exports.KaafilConfigError = KaafilConfigError;
+exports.KaafilDeltaCursorInFlightError = KaafilDeltaCursorInFlightError;
+exports.KaafilEntitlementError = KaafilEntitlementError;
+exports.KaafilError = KaafilError;
+exports.KaafilErrorCode = KaafilErrorCode;
+exports.KaafilInvalidRequestError = KaafilInvalidRequestError;
+exports.KaafilLockedError = KaafilLockedError;
+exports.KaafilNetworkError = KaafilNetworkError;
+exports.KaafilNotFoundError = KaafilNotFoundError;
+exports.KaafilNotImplementedError = KaafilNotImplementedError;
+exports.KaafilPaginationError = KaafilPaginationError;
+exports.KaafilPaginationExhaustedError = KaafilPaginationExhaustedError;
+exports.KaafilPaginationInFlightError = KaafilPaginationInFlightError;
+exports.KaafilRateLimitedError = KaafilRateLimitedError;
+exports.KaafilReadOnlyRoleError = KaafilReadOnlyRoleError;
+exports.KaafilShareTokenExpiredError = KaafilShareTokenExpiredError;
+exports.KaafilShareTokenRevokedError = KaafilShareTokenRevokedError;
+exports.KaafilTimeoutError = KaafilTimeoutError;
+exports.KaafilTransportError = KaafilTransportError;
+exports.KaafilUnauthenticatedError = KaafilUnauthenticatedError;
+exports.KaafilValidationError = KaafilValidationError;
+exports.KaafilVersionConflictError = KaafilVersionConflictError;
+exports.ManagerRole = ManagerRole;
+exports.ManifestMode = ManifestMode;
+exports.OutboxClass = OutboxClass;
+exports.PartyKind = PartyKind;
+exports.PickupKind = PickupKind;
+exports.Retryability = Retryability;
+exports.RoomType = RoomType;
+exports.RoomingFillOrder = RoomingFillOrder;
+exports.RoomingGenderPolicy = RoomingGenderPolicy;
+exports.RoomingHeuristicKey = RoomingHeuristicKey;
+exports.SHADES_PER_FAMILY = SHADES_PER_FAMILY;
+exports.SeatingFillOrder = SeatingFillOrder;
+exports.SeatingGenderAdjacency = SeatingGenderAdjacency;
+exports.SeatingHeuristicKey = SeatingHeuristicKey;
+exports.TONE_FAMILIES = TONE_FAMILIES;
+exports.TriggerAnchor = TriggerAnchor;
+exports.TripMode = TripMode;
+exports.TripStatus = TripStatus;
+exports.UNKNOWN_TONE_FAMILY = UNKNOWN_TONE_FAMILY;
+exports.UnsatisfiableSchemeError = UnsatisfiableSchemeError;
+exports.VehicleLayout = VehicleLayout;
+exports.VehicleType = VehicleType;
+exports.createDeltaCursor = createDeltaCursor;
+exports.isKaafilError = isKaafilError;
+exports.isRetryable = isRetryable;
+exports.isRoomingHeuristicKey = isRoomingHeuristicKey;
+exports.isTombstone = isTombstone;
+exports.mergeDeltaRows = mergeDeltaRows;
+exports.parseRoomingTone = parseRoomingTone;
+exports.roomingHeuristicSeverity = roomingHeuristicSeverity;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map