@fanfare-io/fanfare-sdk-contracts 0.1.0

package/dist/consumer-me.js

@@ -0,0 +1,320 @@
+import * as e from "valibot";
+const t = e.string(), f = e.number(), g = e.record(e.string(), e.unknown()), C = ["ready", "routing", "gated", "routed"], I = ["gated", "routed"], pe = e.picklist(C), he = e.picklist(I), v = [
+  "unavailable",
+  "scheduled",
+  "enterable",
+  "participating",
+  "settling",
+  "granted",
+  "ended"
+], Se = e.picklist(v), T = ["queue", "draw", "auction", "timed_release", "appointment"], h = e.picklist(T), J = ["queue", "draw", "auction", "timed_release", "appointment", "waitlist"], be = e.picklist(J), D = ["queue", "draw", "auction", "timed_release"], R = e.picklist(D), M = ["draw", "auction"], ge = e.picklist(M), x = ["scheduled", "open", "settling", "closed"], j = e.picklist(x), G = ["not_queued", "queued", "granted", "completed", "denied", "left"], P = e.picklist(G), B = ["not_entered", "entered", "won", "completed", "denied"], Q = e.picklist(B), W = ["not_bid", "bidding", "winning", "outbid", "won", "lost"], U = e.picklist(W), E = ["not_entered", "entered", "completed", "denied", "left"], L = e.picklist(E), N = [
+  "not_booked",
+  "booked",
+  "checked_in",
+  "completed",
+  "cancelled",
+  "no_show"
+], z = e.picklist(N), F = ["not_waitlisted", "waitlisted", "notified", "expired", "left"], H = e.picklist(F), K = [
+  "won",
+  "lost",
+  "completed",
+  "denied",
+  "left",
+  "expired",
+  "closed",
+  "cancelled",
+  "no_show"
+], V = e.picklist(K), o = e.strictObject({
+  type: h,
+  id: t,
+  sequenceId: t,
+  lifecycle: j,
+  startsAt: e.optional(t),
+  opensAt: e.optional(t),
+  closesAt: e.optional(t),
+  settlesAt: e.optional(t),
+  details: e.optional(g)
+}), X = e.strictObject({
+  type: h,
+  id: t,
+  sequenceId: t,
+  lifecycle: j,
+  opensAt: e.optional(t),
+  closesAt: e.optional(t),
+  waitlistId: e.optional(t),
+  details: e.optional(g)
+}), d = {
+  id: e.optional(t),
+  distributionId: e.optional(t),
+  enteredAt: e.optional(t),
+  admissionGrant: e.optional(t),
+  grantedAt: e.optional(t),
+  deniedReason: e.optional(t)
+}, O = e.strictObject({
+  status: P,
+  ...d,
+  position: e.optional(f)
+}), w = e.strictObject({
+  status: Q,
+  ...d
+}), y = e.strictObject({
+  status: U,
+  ...d,
+  highestBid: e.optional(t),
+  currentBid: e.optional(t)
+}), k = e.strictObject({
+  status: L,
+  ...d
+}), q = e.strictObject({
+  status: z,
+  id: e.optional(t),
+  distributionId: e.optional(t),
+  slotId: e.optional(t),
+  locationId: e.optional(t),
+  bookedAt: e.optional(t),
+  checkedInAt: e.optional(t),
+  completedAt: e.optional(t),
+  cancelledAt: e.optional(t),
+  noShowAt: e.optional(t)
+}), _ = e.strictObject({
+  status: H,
+  id: e.optional(t),
+  waitlistId: e.optional(t),
+  enteredAt: e.optional(t),
+  notifiedAt: e.optional(t)
+}), je = e.union([
+  O,
+  w,
+  y,
+  k,
+  q,
+  _
+]), l = e.strictObject({
+  token: t,
+  distributionType: R,
+  distributionId: t,
+  sequenceId: t,
+  experienceId: t,
+  issuedAt: e.optional(t),
+  expiresAt: e.optional(t),
+  handoffUrl: e.optional(t)
+}), a = e.strictObject({
+  type: V,
+  reason: e.optional(t),
+  at: e.optional(t),
+  distributionType: e.optional(h),
+  distributionId: e.optional(t)
+}), b = {
+  scheduled: {
+    queue: ["not_queued"],
+    draw: ["not_entered"],
+    auction: ["not_bid"],
+    timed_release: ["not_entered"],
+    appointment: ["not_booked"]
+  },
+  enterable: {
+    queue: ["not_queued"],
+    draw: ["not_entered"],
+    auction: ["not_bid"],
+    timed_release: ["not_entered"],
+    appointment: ["not_booked"],
+    waitlist: ["not_waitlisted"]
+  },
+  participating: {
+    queue: ["queued"],
+    draw: ["entered"],
+    auction: ["bidding", "winning", "outbid"],
+    timed_release: ["entered"],
+    appointment: ["booked", "checked_in"],
+    waitlist: ["waitlisted", "notified"]
+  },
+  settling: {
+    draw: ["not_entered", "entered"],
+    auction: ["not_bid", "bidding", "winning", "outbid"]
+  }
+};
+function Y(n) {
+  if (typeof n != "object" || n === null) return !0;
+  const i = n;
+  return i.phase === "unavailable" || i.phase === "ended" || i.phase === "granted" || !i.phase || !i.mechanism || !i.consumer?.status || !(i.phase in b) ? !0 : b[i.phase][i.mechanism]?.includes(i.consumer.status) ?? !0;
+}
+const Z = e.strictObject({
+  phase: e.literal("unavailable"),
+  reason: e.optional(t)
+}), r = {
+  mechanism: e.literal("queue"),
+  distribution: o,
+  consumer: O
+}, s = {
+  mechanism: e.literal("draw"),
+  distribution: o,
+  consumer: w
+}, c = {
+  mechanism: e.literal("auction"),
+  distribution: o,
+  consumer: y
+}, u = {
+  mechanism: e.literal("timed_release"),
+  distribution: o,
+  consumer: k
+}, m = {
+  mechanism: e.literal("appointment"),
+  distribution: o,
+  consumer: q
+}, S = {
+  mechanism: e.literal("waitlist"),
+  target: X,
+  consumer: _
+}, $ = e.union([
+  e.strictObject({ phase: e.literal("scheduled"), ...r }),
+  e.strictObject({ phase: e.literal("scheduled"), ...s }),
+  e.strictObject({ phase: e.literal("scheduled"), ...c }),
+  e.strictObject({ phase: e.literal("scheduled"), ...u }),
+  e.strictObject({ phase: e.literal("scheduled"), ...m })
+]), ee = e.union([
+  e.strictObject({ phase: e.literal("enterable"), ...r }),
+  e.strictObject({ phase: e.literal("enterable"), ...s }),
+  e.strictObject({ phase: e.literal("enterable"), ...c }),
+  e.strictObject({ phase: e.literal("enterable"), ...u }),
+  e.strictObject({ phase: e.literal("enterable"), ...m }),
+  e.strictObject({ phase: e.literal("enterable"), ...S })
+]), te = e.union([
+  e.strictObject({ phase: e.literal("participating"), ...r }),
+  e.strictObject({ phase: e.literal("participating"), ...s }),
+  e.strictObject({ phase: e.literal("participating"), ...c }),
+  e.strictObject({ phase: e.literal("participating"), ...u }),
+  e.strictObject({ phase: e.literal("participating"), ...m }),
+  e.strictObject({ phase: e.literal("participating"), ...S })
+]), ne = e.union([
+  e.strictObject({ phase: e.literal("settling"), ...s }),
+  e.strictObject({ phase: e.literal("settling"), ...c })
+]), ie = e.union([
+  e.strictObject({ phase: e.literal("granted"), ...r, grant: l }),
+  e.strictObject({ phase: e.literal("granted"), ...s, grant: l }),
+  e.strictObject({ phase: e.literal("granted"), ...c, grant: l }),
+  e.strictObject({ phase: e.literal("granted"), ...u, grant: l })
+]), ae = e.union([
+  e.strictObject({ phase: e.literal("ended"), ...r, outcome: a }),
+  e.strictObject({ phase: e.literal("ended"), ...s, outcome: a }),
+  e.strictObject({ phase: e.literal("ended"), ...c, outcome: a }),
+  e.strictObject({ phase: e.literal("ended"), ...u, outcome: a }),
+  e.strictObject({ phase: e.literal("ended"), ...m, outcome: a }),
+  e.strictObject({ phase: e.literal("ended"), ...S, outcome: a })
+]), se = e.pipe(
+  e.union([
+    Z,
+    $,
+    ee,
+    te,
+    ne,
+    ie,
+    ae
+  ]),
+  e.check(
+    (n) => n.phase === "unavailable" || n.mechanism !== "waitlist" && n.distribution.type === n.mechanism || n.mechanism === "waitlist",
+    "sequence mechanism must match its distribution or target"
+  ),
+  e.check(
+    (n) => n.phase === "granted" || !("grant" in n),
+    "grant is only valid on granted sequences"
+  ),
+  e.check(
+    (n) => n.phase === "ended" || !("outcome" in n),
+    "outcome is only valid on ended sequences"
+  ),
+  e.check(
+    (n) => n.phase !== "granted" || n.grant.distributionType === n.mechanism,
+    "grant distributionType must match sequence mechanism"
+  ),
+  e.check(
+    (n) => Y(n),
+    "consumer status must match sequence phase and mechanism"
+  ),
+  e.check((n) => {
+    if (n.phase !== "granted") return !0;
+    switch (n.mechanism) {
+      case "queue":
+        return n.consumer.status === "granted";
+      case "draw":
+      case "auction":
+        return n.consumer.status === "won";
+      case "timed_release":
+        return n.consumer.status === "completed";
+      default:
+        return !1;
+    }
+  }, "granted consumer status must match sequence mechanism")
+), p = {
+  experienceId: t,
+  updatedAt: e.optional(t)
+}, ce = e.strictObject({
+  ...p,
+  journeyStage: e.literal("ready")
+}), oe = e.strictObject({
+  ...p,
+  journeyStage: e.literal("routing")
+}), re = e.strictObject({
+  ...p,
+  journeyStage: e.literal("gated"),
+  gates: e.array(e.unknown()),
+  selected: e.optional(
+    e.strictObject({
+      sequenceId: t
+    })
+  )
+}), ue = e.strictObject({
+  ...p,
+  journeyStage: e.literal("routed"),
+  sequenceId: t,
+  sequence: se,
+  offers: e.optional(e.array(e.unknown()))
+}), A = e.union([re, ue]), Oe = e.union([
+  ce,
+  oe,
+  A
+]), le = e.strictObject({
+  journeys: e.array(A)
+}), we = e.looseObject({
+  active: le
+});
+export {
+  l as AdmissionGrantSchema,
+  z as AppointmentConsumerStatusSchema,
+  N as AppointmentConsumerStatuses,
+  U as AuctionConsumerStatusSchema,
+  W as AuctionConsumerStatuses,
+  Oe as ConsumerJourneyStateSchema,
+  we as ConsumerMeResponseSchema,
+  je as ConsumerSequenceStateSchema,
+  j as DistributionLifecycleSchema,
+  x as DistributionLifecycles,
+  o as DistributionStateSchema,
+  X as DistributionTargetSchema,
+  h as DistributionTypeSchema,
+  T as DistributionTypes,
+  Q as DrawConsumerStatusSchema,
+  B as DrawConsumerStatuses,
+  R as GrantProducingMechanismSchema,
+  D as GrantProducingMechanisms,
+  pe as JourneyStageSchema,
+  C as JourneyStages,
+  P as QueueConsumerStatusSchema,
+  G as QueueConsumerStatuses,
+  be as SequenceMechanismSchema,
+  J as SequenceMechanisms,
+  a as SequenceOutcomeSchema,
+  V as SequenceOutcomeTypeSchema,
+  K as SequenceOutcomeTypes,
+  Se as SequencePhaseSchema,
+  v as SequencePhases,
+  se as SequenceStateSchema,
+  he as ServiceJourneyStageSchema,
+  I as ServiceJourneyStages,
+  A as ServiceJourneyStateSchema,
+  ge as SettlingMechanismSchema,
+  M as SettlingMechanisms,
+  L as TimedReleaseConsumerStatusSchema,
+  E as TimedReleaseConsumerStatuses,
+  H as WaitlistConsumerStatusSchema,
+  F as WaitlistConsumerStatuses
+};

package/dist/errors.d.ts

@@ -0,0 +1,147 @@
+import { InferOutput } from 'valibot';
+import * as v from "valibot";
+/**
+ * Canonical Fanfare API error contract.
+ *
+ * SCREAMING_SNAKE is the single canonical casing for every wire/contract code.
+ * Codes are grouped by domain. The full tuple + union live below so SDKs and
+ * services can both narrow on `ErrorCode` and validate the canonical envelope.
+ */
+export declare const CommonErrorCodes: {
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly RATE_LIMIT_UNAVAILABLE: "RATE_LIMIT_UNAVAILABLE";
+    readonly PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+};
+export declare const AuthErrorCodes: {
+    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
+    readonly INVALID_SESSION: "INVALID_SESSION";
+    readonly INVALID_REFRESH_TOKEN: "INVALID_REFRESH_TOKEN";
+    readonly OTP_INVALID: "OTP_INVALID";
+    readonly OTP_EXPIRED: "OTP_EXPIRED";
+};
+export declare const CapabilityErrorCodes: {
+    readonly ENTRY_TOKEN_REQUIRED: "ENTRY_TOKEN_REQUIRED";
+    readonly ENTRY_TOKEN_INVALID: "ENTRY_TOKEN_INVALID";
+    readonly ENTRY_TOKEN_EXPIRED: "ENTRY_TOKEN_EXPIRED";
+    readonly ENTRY_TOKEN_MISMATCH: "ENTRY_TOKEN_MISMATCH";
+};
+export declare const AppointmentErrorCodes: {
+    readonly SLOT_EXPIRED: "SLOT_EXPIRED";
+    readonly SLOT_OUT_OF_WINDOW: "SLOT_OUT_OF_WINDOW";
+    readonly SLOT_NOT_AVAILABLE: "SLOT_NOT_AVAILABLE";
+    readonly ALREADY_BOOKED: "ALREADY_BOOKED";
+    readonly ACTIVE_BOOKING_EXISTS: "ACTIVE_BOOKING_EXISTS";
+    readonly NO_EXISTING_BOOKING: "NO_EXISTING_BOOKING";
+    readonly INVALID_SLOT: "INVALID_SLOT";
+    readonly NEW_SLOT_FULL: "NEW_SLOT_FULL";
+    readonly CANNOT_CANCEL_ONGOING_OR_PAST: "CANNOT_CANCEL_ONGOING_OR_PAST";
+};
+export declare const FingerprintErrorCodes: {
+    readonly FINGERPRINT_REQUIRED: "FINGERPRINT_REQUIRED";
+    readonly FINGERPRINT_DEVICE_MISMATCH: "FINGERPRINT_DEVICE_MISMATCH";
+    readonly FINGERPRINT_INVALID: "FINGERPRINT_INVALID";
+};
+export declare const DistributionErrorCodes: {
+    readonly DISTRIBUTION_NOT_OPEN: "DISTRIBUTION_NOT_OPEN";
+    readonly DISTRIBUTION_CLOSED: "DISTRIBUTION_CLOSED";
+    readonly DISTRIBUTION_FULL: "DISTRIBUTION_FULL";
+};
+export declare const AdmissionErrorCodes: {
+    readonly ADMISSION_KEY_THUMBPRINT_REQUIRED: "ADMISSION_KEY_THUMBPRINT_REQUIRED";
+    readonly ADMISSION_PROOF_REQUIRED: "ADMISSION_PROOF_REQUIRED";
+    readonly ADMISSION_GRANT_INVALID: "ADMISSION_GRANT_INVALID";
+    readonly ADMISSION_ORIGINAL_ENTRY_REQUIRED: "ADMISSION_ORIGINAL_ENTRY_REQUIRED";
+    readonly ADMISSION_KEY_MISMATCH: "ADMISSION_KEY_MISMATCH";
+};
+export declare const BotChallengeErrorCodes: {
+    readonly BOT_CHALLENGE_INVALID: "BOT_CHALLENGE_INVALID";
+    readonly BOT_CHALLENGE_EXPIRED: "BOT_CHALLENGE_EXPIRED";
+    readonly BOT_CHALLENGE_SUBJECT_MISMATCH: "BOT_CHALLENGE_SUBJECT_MISMATCH";
+};
+export declare const ErrorCodeMap: {
+    readonly BOT_CHALLENGE_INVALID: "BOT_CHALLENGE_INVALID";
+    readonly BOT_CHALLENGE_EXPIRED: "BOT_CHALLENGE_EXPIRED";
+    readonly BOT_CHALLENGE_SUBJECT_MISMATCH: "BOT_CHALLENGE_SUBJECT_MISMATCH";
+    readonly ADMISSION_KEY_THUMBPRINT_REQUIRED: "ADMISSION_KEY_THUMBPRINT_REQUIRED";
+    readonly ADMISSION_PROOF_REQUIRED: "ADMISSION_PROOF_REQUIRED";
+    readonly ADMISSION_GRANT_INVALID: "ADMISSION_GRANT_INVALID";
+    readonly ADMISSION_ORIGINAL_ENTRY_REQUIRED: "ADMISSION_ORIGINAL_ENTRY_REQUIRED";
+    readonly ADMISSION_KEY_MISMATCH: "ADMISSION_KEY_MISMATCH";
+    readonly DISTRIBUTION_NOT_OPEN: "DISTRIBUTION_NOT_OPEN";
+    readonly DISTRIBUTION_CLOSED: "DISTRIBUTION_CLOSED";
+    readonly DISTRIBUTION_FULL: "DISTRIBUTION_FULL";
+    readonly FINGERPRINT_REQUIRED: "FINGERPRINT_REQUIRED";
+    readonly FINGERPRINT_DEVICE_MISMATCH: "FINGERPRINT_DEVICE_MISMATCH";
+    readonly FINGERPRINT_INVALID: "FINGERPRINT_INVALID";
+    readonly SLOT_EXPIRED: "SLOT_EXPIRED";
+    readonly SLOT_OUT_OF_WINDOW: "SLOT_OUT_OF_WINDOW";
+    readonly SLOT_NOT_AVAILABLE: "SLOT_NOT_AVAILABLE";
+    readonly ALREADY_BOOKED: "ALREADY_BOOKED";
+    readonly ACTIVE_BOOKING_EXISTS: "ACTIVE_BOOKING_EXISTS";
+    readonly NO_EXISTING_BOOKING: "NO_EXISTING_BOOKING";
+    readonly INVALID_SLOT: "INVALID_SLOT";
+    readonly NEW_SLOT_FULL: "NEW_SLOT_FULL";
+    readonly CANNOT_CANCEL_ONGOING_OR_PAST: "CANNOT_CANCEL_ONGOING_OR_PAST";
+    readonly ENTRY_TOKEN_REQUIRED: "ENTRY_TOKEN_REQUIRED";
+    readonly ENTRY_TOKEN_INVALID: "ENTRY_TOKEN_INVALID";
+    readonly ENTRY_TOKEN_EXPIRED: "ENTRY_TOKEN_EXPIRED";
+    readonly ENTRY_TOKEN_MISMATCH: "ENTRY_TOKEN_MISMATCH";
+    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
+    readonly INVALID_SESSION: "INVALID_SESSION";
+    readonly INVALID_REFRESH_TOKEN: "INVALID_REFRESH_TOKEN";
+    readonly OTP_INVALID: "OTP_INVALID";
+    readonly OTP_EXPIRED: "OTP_EXPIRED";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly RATE_LIMIT_UNAVAILABLE: "RATE_LIMIT_UNAVAILABLE";
+    readonly PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+};
+export declare const ErrorCodes: readonly ["VALIDATION_ERROR", "UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "RATE_LIMITED", "RATE_LIMIT_UNAVAILABLE", "PAYLOAD_TOO_LARGE", "INTERNAL_ERROR", "SERVICE_UNAVAILABLE", "INVALID_CREDENTIALS", "INVALID_SESSION", "INVALID_REFRESH_TOKEN", "OTP_INVALID", "OTP_EXPIRED", "ENTRY_TOKEN_REQUIRED", "ENTRY_TOKEN_INVALID", "ENTRY_TOKEN_EXPIRED", "ENTRY_TOKEN_MISMATCH", "SLOT_EXPIRED", "SLOT_OUT_OF_WINDOW", "SLOT_NOT_AVAILABLE", "ALREADY_BOOKED", "ACTIVE_BOOKING_EXISTS", "NO_EXISTING_BOOKING", "INVALID_SLOT", "NEW_SLOT_FULL", "CANNOT_CANCEL_ONGOING_OR_PAST", "FINGERPRINT_REQUIRED", "FINGERPRINT_DEVICE_MISMATCH", "FINGERPRINT_INVALID", "DISTRIBUTION_NOT_OPEN", "DISTRIBUTION_CLOSED", "DISTRIBUTION_FULL", "ADMISSION_KEY_THUMBPRINT_REQUIRED", "ADMISSION_PROOF_REQUIRED", "ADMISSION_GRANT_INVALID", "ADMISSION_ORIGINAL_ENTRY_REQUIRED", "ADMISSION_KEY_MISMATCH", "BOT_CHALLENGE_INVALID", "BOT_CHALLENGE_EXPIRED", "BOT_CHALLENGE_SUBJECT_MISMATCH"];
+export type ErrorCode = (typeof ErrorCodes)[number];
+export declare const ErrorCodeSchema: v.PicklistSchema<readonly ["VALIDATION_ERROR", "UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "RATE_LIMITED", "RATE_LIMIT_UNAVAILABLE", "PAYLOAD_TOO_LARGE", "INTERNAL_ERROR", "SERVICE_UNAVAILABLE", "INVALID_CREDENTIALS", "INVALID_SESSION", "INVALID_REFRESH_TOKEN", "OTP_INVALID", "OTP_EXPIRED", "ENTRY_TOKEN_REQUIRED", "ENTRY_TOKEN_INVALID", "ENTRY_TOKEN_EXPIRED", "ENTRY_TOKEN_MISMATCH", "SLOT_EXPIRED", "SLOT_OUT_OF_WINDOW", "SLOT_NOT_AVAILABLE", "ALREADY_BOOKED", "ACTIVE_BOOKING_EXISTS", "NO_EXISTING_BOOKING", "INVALID_SLOT", "NEW_SLOT_FULL", "CANNOT_CANCEL_ONGOING_OR_PAST", "FINGERPRINT_REQUIRED", "FINGERPRINT_DEVICE_MISMATCH", "FINGERPRINT_INVALID", "DISTRIBUTION_NOT_OPEN", "DISTRIBUTION_CLOSED", "DISTRIBUTION_FULL", "ADMISSION_KEY_THUMBPRINT_REQUIRED", "ADMISSION_PROOF_REQUIRED", "ADMISSION_GRANT_INVALID", "ADMISSION_ORIGINAL_ENTRY_REQUIRED", "ADMISSION_KEY_MISMATCH", "BOT_CHALLENGE_INVALID", "BOT_CHALLENGE_EXPIRED", "BOT_CHALLENGE_SUBJECT_MISMATCH"], undefined>;
+export declare const ValidationIssueSchema: v.ObjectSchema<{
+    readonly path: v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+    readonly message: v.StringSchema<undefined>;
+    readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type ValidationIssue = InferOutput<typeof ValidationIssueSchema>;
+export declare const ErrorSupportSchema: v.ObjectSchema<{
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly referenceCode: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly confirmationCode: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type ErrorSupport = InferOutput<typeof ErrorSupportSchema>;
+/**
+ * Canonical error envelope returned by the consumer API. `code` is the single
+ * machine-readable discriminator.
+ * `action` is open-ended ("reroute" today) so clients can react to flow hints
+ * without a contract bump per action.
+ */
+export declare const ConsumerApiErrorSchema: v.ObjectSchema<{
+    readonly code: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly path: v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly action: v.OptionalSchema<v.UnionSchema<[v.LiteralSchema<"reroute", undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+    readonly support: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly referenceCode: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly confirmationCode: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type ConsumerApiError = InferOutput<typeof ConsumerApiErrorSchema>;

package/dist/errors.js

@@ -0,0 +1,133 @@
+import * as I from "valibot";
+const E = {
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  RATE_LIMITED: "RATE_LIMITED",
+  RATE_LIMIT_UNAVAILABLE: "RATE_LIMIT_UNAVAILABLE",
+  PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE"
+}, N = {
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  INVALID_SESSION: "INVALID_SESSION",
+  INVALID_REFRESH_TOKEN: "INVALID_REFRESH_TOKEN",
+  OTP_INVALID: "OTP_INVALID",
+  OTP_EXPIRED: "OTP_EXPIRED"
+}, T = {
+  ENTRY_TOKEN_REQUIRED: "ENTRY_TOKEN_REQUIRED",
+  ENTRY_TOKEN_INVALID: "ENTRY_TOKEN_INVALID",
+  ENTRY_TOKEN_EXPIRED: "ENTRY_TOKEN_EXPIRED",
+  ENTRY_TOKEN_MISMATCH: "ENTRY_TOKEN_MISMATCH"
+}, _ = {
+  SLOT_EXPIRED: "SLOT_EXPIRED",
+  SLOT_OUT_OF_WINDOW: "SLOT_OUT_OF_WINDOW",
+  SLOT_NOT_AVAILABLE: "SLOT_NOT_AVAILABLE",
+  ALREADY_BOOKED: "ALREADY_BOOKED",
+  ACTIVE_BOOKING_EXISTS: "ACTIVE_BOOKING_EXISTS",
+  NO_EXISTING_BOOKING: "NO_EXISTING_BOOKING",
+  INVALID_SLOT: "INVALID_SLOT",
+  NEW_SLOT_FULL: "NEW_SLOT_FULL",
+  CANNOT_CANCEL_ONGOING_OR_PAST: "CANNOT_CANCEL_ONGOING_OR_PAST"
+}, A = {
+  FINGERPRINT_REQUIRED: "FINGERPRINT_REQUIRED",
+  FINGERPRINT_DEVICE_MISMATCH: "FINGERPRINT_DEVICE_MISMATCH",
+  FINGERPRINT_INVALID: "FINGERPRINT_INVALID"
+}, R = {
+  DISTRIBUTION_NOT_OPEN: "DISTRIBUTION_NOT_OPEN",
+  DISTRIBUTION_CLOSED: "DISTRIBUTION_CLOSED",
+  DISTRIBUTION_FULL: "DISTRIBUTION_FULL"
+}, O = {
+  ADMISSION_KEY_THUMBPRINT_REQUIRED: "ADMISSION_KEY_THUMBPRINT_REQUIRED",
+  ADMISSION_PROOF_REQUIRED: "ADMISSION_PROOF_REQUIRED",
+  ADMISSION_GRANT_INVALID: "ADMISSION_GRANT_INVALID",
+  ADMISSION_ORIGINAL_ENTRY_REQUIRED: "ADMISSION_ORIGINAL_ENTRY_REQUIRED",
+  ADMISSION_KEY_MISMATCH: "ADMISSION_KEY_MISMATCH"
+}, L = {
+  BOT_CHALLENGE_INVALID: "BOT_CHALLENGE_INVALID",
+  BOT_CHALLENGE_EXPIRED: "BOT_CHALLENGE_EXPIRED",
+  BOT_CHALLENGE_SUBJECT_MISMATCH: "BOT_CHALLENGE_SUBJECT_MISMATCH"
+}, r = {
+  ...E,
+  ...N,
+  ...T,
+  ..._,
+  ...A,
+  ...R,
+  ...O,
+  ...L
+}, D = [
+  E.VALIDATION_ERROR,
+  E.UNAUTHORIZED,
+  E.FORBIDDEN,
+  E.NOT_FOUND,
+  E.RATE_LIMITED,
+  E.RATE_LIMIT_UNAVAILABLE,
+  E.PAYLOAD_TOO_LARGE,
+  E.INTERNAL_ERROR,
+  E.SERVICE_UNAVAILABLE,
+  N.INVALID_CREDENTIALS,
+  N.INVALID_SESSION,
+  N.INVALID_REFRESH_TOKEN,
+  N.OTP_INVALID,
+  N.OTP_EXPIRED,
+  T.ENTRY_TOKEN_REQUIRED,
+  T.ENTRY_TOKEN_INVALID,
+  T.ENTRY_TOKEN_EXPIRED,
+  T.ENTRY_TOKEN_MISMATCH,
+  _.SLOT_EXPIRED,
+  _.SLOT_OUT_OF_WINDOW,
+  _.SLOT_NOT_AVAILABLE,
+  _.ALREADY_BOOKED,
+  _.ACTIVE_BOOKING_EXISTS,
+  _.NO_EXISTING_BOOKING,
+  _.INVALID_SLOT,
+  _.NEW_SLOT_FULL,
+  _.CANNOT_CANCEL_ONGOING_OR_PAST,
+  A.FINGERPRINT_REQUIRED,
+  A.FINGERPRINT_DEVICE_MISMATCH,
+  A.FINGERPRINT_INVALID,
+  R.DISTRIBUTION_NOT_OPEN,
+  R.DISTRIBUTION_CLOSED,
+  R.DISTRIBUTION_FULL,
+  O.ADMISSION_KEY_THUMBPRINT_REQUIRED,
+  O.ADMISSION_PROOF_REQUIRED,
+  O.ADMISSION_GRANT_INVALID,
+  O.ADMISSION_ORIGINAL_ENTRY_REQUIRED,
+  O.ADMISSION_KEY_MISMATCH,
+  L.BOT_CHALLENGE_INVALID,
+  L.BOT_CHALLENGE_EXPIRED,
+  L.BOT_CHALLENGE_SUBJECT_MISMATCH
+], C = I.picklist(D), S = I.object({
+  path: I.optional(I.array(I.union([I.string(), I.number()]))),
+  message: I.string(),
+  code: I.optional(I.string())
+}), o = I.object({
+  message: I.optional(I.string()),
+  referenceCode: I.optional(I.string()),
+  confirmationCode: I.optional(I.string())
+}), t = I.object({
+  code: I.pipe(I.string(), I.regex(/^[A-Z][A-Z0-9_]*$/)),
+  message: I.optional(I.string()),
+  details: I.optional(I.unknown()),
+  issues: I.optional(I.array(S)),
+  action: I.optional(I.union([I.literal("reroute"), I.string()])),
+  support: I.optional(o)
+});
+export {
+  O as AdmissionErrorCodes,
+  _ as AppointmentErrorCodes,
+  N as AuthErrorCodes,
+  L as BotChallengeErrorCodes,
+  T as CapabilityErrorCodes,
+  E as CommonErrorCodes,
+  t as ConsumerApiErrorSchema,
+  R as DistributionErrorCodes,
+  r as ErrorCodeMap,
+  C as ErrorCodeSchema,
+  D as ErrorCodes,
+  o as ErrorSupportSchema,
+  A as FingerprintErrorCodes,
+  S as ValidationIssueSchema
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './errors';
+export * from './routing';
+export * from './theme';

package/dist/index.js

@@ -0,0 +1,62 @@
+import { AdmissionErrorCodes as a, AppointmentErrorCodes as i, AuthErrorCodes as n, BotChallengeErrorCodes as r, CapabilityErrorCodes as t, CommonErrorCodes as h, ConsumerApiErrorSchema as m, DistributionErrorCodes as s, ErrorCodeMap as c, ErrorCodeSchema as d, ErrorCodes as S, ErrorSupportSchema as g, FingerprintErrorCodes as C, ValidationIssueSchema as u } from "./errors.js";
+import { AccessCodeRoutingGateV1Schema as l, AdmissibleRoutingCandidateV1Schema as V, AuthenticationRoutingGateV1Schema as p, BotCheckRoutingGateV1Schema as E, ChallengeProvider as A, ChallengePurpose as D, ChallengeType as f, DeniedRoutingCandidateV1Schema as G, GatedDecisionV1Schema as v, GatedRoutingCandidateV1Schema as B, NoAccessDecisionV1Schema as P, RiskAssessmentSchema as T, RiskLevel as k, RiskLevelSchema as x, RiskLevels as y, RoutedDecisionV1Schema as b, RoutingCandidateSchema as L, RoutingCandidateV1Schema as q, RoutingDecisionSchema as M, RoutingDecisionV1Schema as W, RoutingGateSchema as F, RoutingGateV1Schema as I, RoutingReasonCodeSchema as N, RoutingReasonCodeV1Schema as j, RoutingReasonCodesV1 as w, RoutingReasonSchema as z, RoutingReasonV1Schema as H, RoutingSequenceRefSchema as J, RoutingSequenceRefV1Schema as K } from "./routing.js";
+import { BrandThemeSchema as Q, DefaultBrandTheme as U, WidgetVariantSchema as X, WidgetVariants as Y, mergeBrandTheme as Z } from "./theme.js";
+import { BotMitigationStateSchema as $, ChallengeProviderSchema as ee, ChallengeProviders as oe, ChallengePurposeSchema as ae, ChallengePurposes as ie, ChallengeTypeSchema as ne, ChallengeTypes as re, RoutingChallengeSchema as te } from "./challenges.js";
+export {
+  l as AccessCodeRoutingGateV1Schema,
+  V as AdmissibleRoutingCandidateV1Schema,
+  a as AdmissionErrorCodes,
+  i as AppointmentErrorCodes,
+  n as AuthErrorCodes,
+  p as AuthenticationRoutingGateV1Schema,
+  r as BotChallengeErrorCodes,
+  E as BotCheckRoutingGateV1Schema,
+  $ as BotMitigationStateSchema,
+  Q as BrandThemeSchema,
+  t as CapabilityErrorCodes,
+  A as ChallengeProvider,
+  ee as ChallengeProviderSchema,
+  oe as ChallengeProviders,
+  D as ChallengePurpose,
+  ae as ChallengePurposeSchema,
+  ie as ChallengePurposes,
+  f as ChallengeType,
+  ne as ChallengeTypeSchema,
+  re as ChallengeTypes,
+  h as CommonErrorCodes,
+  m as ConsumerApiErrorSchema,
+  U as DefaultBrandTheme,
+  G as DeniedRoutingCandidateV1Schema,
+  s as DistributionErrorCodes,
+  c as ErrorCodeMap,
+  d as ErrorCodeSchema,
+  S as ErrorCodes,
+  g as ErrorSupportSchema,
+  C as FingerprintErrorCodes,
+  v as GatedDecisionV1Schema,
+  B as GatedRoutingCandidateV1Schema,
+  P as NoAccessDecisionV1Schema,
+  T as RiskAssessmentSchema,
+  k as RiskLevel,
+  x as RiskLevelSchema,
+  y as RiskLevels,
+  b as RoutedDecisionV1Schema,
+  L as RoutingCandidateSchema,
+  q as RoutingCandidateV1Schema,
+  te as RoutingChallengeSchema,
+  M as RoutingDecisionSchema,
+  W as RoutingDecisionV1Schema,
+  F as RoutingGateSchema,
+  I as RoutingGateV1Schema,
+  N as RoutingReasonCodeSchema,
+  j as RoutingReasonCodeV1Schema,
+  w as RoutingReasonCodesV1,
+  z as RoutingReasonSchema,
+  H as RoutingReasonV1Schema,
+  J as RoutingSequenceRefSchema,
+  K as RoutingSequenceRefV1Schema,
+  u as ValidationIssueSchema,
+  X as WidgetVariantSchema,
+  Y as WidgetVariants,
+  Z as mergeBrandTheme
+};