@fanfare-io/fanfare-sdk-contracts 0.11.0 → 0.13.0

package/README.md

@@ -17,6 +17,16 @@ npm install @fanfare-io/fanfare-sdk-contracts
 - [Website](https://www.fanfare.io)
 - [Source & issues](https://github.com/fanfare-io/fanfare-sdk)
 
+## Response schema compatibility
+
+Choose the Valibot object mode based on the compatibility contract of the payload:
+
+- `v.strictObject` rejects unknown keys. Use it only for deliberately closed contracts, and document why additive server fields must be rejected.
+- `v.object` validates known fields and strips unknown keys. Use it when callers should remain compatible with additive fields but should not receive them.
+- `v.looseObject` validates known fields and preserves unknown keys. Use it when forward-compatible fields must survive validation.
+
+This choice is made per endpoint and may differ between a response root and its nested objects. SDK response parsing validates server payloads at runtime, so tightening a nested object can turn an otherwise additive server change into a client-visible validation failure. Treat such changes as coordinated contract changes rather than incidental schema cleanup.
+
 ## License
 
 [Apache-2.0](./LICENSE)

package/dist/auction.d.ts

@@ -6,6 +6,7 @@ export declare const AuctionBidderStateResponseSchema: v.LooseObjectSchema<{
     readonly winningBidAmount: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
     readonly bidCount: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
     readonly admissionGrant: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly degraded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type AuctionBidderStateResponse = InferOutput<typeof AuctionBidderStateResponseSchema>;
 export declare const AuctionHighestBidResponseSchema: v.LooseObjectSchema<{

package/dist/auction.js

@@ -1,17 +1,21 @@
-import * as t from "valibot";
-const n = t.string(), o = t.pipe(n, t.regex(/^\d{1,12}(\.\d{1,8})?$/)), e = t.picklist(["NOT_BID", "BIDDING", "WINNING", "OUTBID", "WON", "LOST"]), s = t.looseObject({
-  status: e,
-  lastBidAmount: t.nullish(o),
-  winningBidAmount: t.optional(o),
-  bidCount: t.optional(t.number()),
-  admissionGrant: t.optional(n)
-}), a = t.looseObject({
-  amount: o
-}), i = t.looseObject({
-  amount: o,
-  timestamp: n,
-  isHighest: t.boolean()
-}), c = t.array(i);
+import * as o from "valibot";
+const e = o.string(), t = o.pipe(e, o.regex(/^\d{1,12}(\.\d{1,8})?$/)), n = o.picklist(["NOT_BID", "BIDDING", "WINNING", "OUTBID", "WON", "LOST"]), s = o.looseObject({
+  status: n,
+  lastBidAmount: o.nullish(t),
+  winningBidAmount: o.optional(t),
+  bidCount: o.optional(o.number()),
+  admissionGrant: o.optional(e),
+  // The bid is committed, but a post-commit effect (event fan-out, credential mint) did not
+  // complete on this request. The standing is authoritative; a later status read reconciles
+  // whatever the effect would have projected.
+  degraded: o.optional(o.boolean())
+}), a = o.looseObject({
+  amount: t
+}), i = o.looseObject({
+  amount: t,
+  timestamp: e,
+  isHighest: o.boolean()
+}), c = o.array(i);
 export {
   i as AuctionBidHistoryItemResponseSchema,
   c as AuctionBidHistoryResponseSchema,

package/dist/bridge.d.ts

@@ -0,0 +1,168 @@
+import { DistributionType, SequenceOutcomeType } from './consumer-me';
+/**
+ * Name of the DOM `CustomEvent` dispatched whenever the journey's projected
+ * state changes.
+ *
+ * One event name covers the whole journey: granted and ended are phase edges
+ * within it, not separate events.
+ */
+export declare const FANFARE_STATE_CHANGE_EVENT: "fanfare:state-change";
+/**
+ * Version of the {@link FanfareStateChangeDetail} payload.
+ *
+ * Bumped only on a breaking payload change; additive fields leave it alone.
+ * Consumers compare `detail.version === 1` and ignore versions they do not
+ * recognise.
+ */
+export declare const BRIDGE_EVENT_VERSION = 1;
+/** Fields every payload arm carries, whatever the journey stage. */
+interface FanfareStateChangeBase {
+    /** Payload version; compare against `1` and ignore unrecognised versions. */
+    version: number;
+    /** Experience the payload describes; the attribution key across shadow roots. */
+    experienceId: string;
+}
+/** The journey exists and has not started routing. */
+export interface FanfareReadyDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "ready";
+}
+/** The journey is resolving which sequence the consumer belongs to. */
+export interface FanfareRoutingDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routing";
+}
+/** The journey is held behind a gate the consumer has not cleared. */
+export interface FanfareGatedDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "gated";
+}
+/** The routed sequence offers nothing for this consumer; no mechanism is reported. */
+export interface FanfareUnavailableDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "unavailable";
+}
+/** The routed sequence has not opened yet. */
+export interface FanfareScheduledDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "scheduled";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: DistributionType;
+}
+/** The routed sequence is open and the consumer may enter. */
+export interface FanfareEnterableDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "enterable";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: DistributionType;
+}
+/**
+ * The consumer is participating in a queue.
+ *
+ * The only arm carrying `position`: queue is the sole mechanism whose consumer
+ * state reports one.
+ */
+export interface FanfareQueueParticipatingDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "participating";
+    /** Distribution mechanism discriminator. */
+    mechanism: "queue";
+    /** Live queue position, when the server reports one. Event-carried only — never stamped. */
+    position?: number;
+}
+/** The consumer is participating in a sequence whose mechanism reports no position. */
+export interface FanfareParticipatingDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "participating";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: Exclude<DistributionType, "queue">;
+}
+/** The sequence has closed and is resolving its outcome. */
+export interface FanfareSettlingDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "settling";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: DistributionType;
+}
+/** The consumer holds a reservation and must complete checkout before it expires. */
+export interface FanfareReservedDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "reserved";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: DistributionType;
+    /**
+     * Reservation expiry as epoch milliseconds.
+     *
+     * Absent — rather than `NaN`, `0` or `null` — whenever the server sent a
+     * value that could not be parsed into a timestamp.
+     */
+    expiresAt?: number;
+}
+/** The consumer has been admitted and holds a grant. */
+export interface FanfareGrantedDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "granted";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: DistributionType;
+    /**
+     * Grant expiry as epoch milliseconds.
+     *
+     * Absent — rather than `NaN`, `0` or `null` — whenever the server sent a
+     * value that could not be parsed into a timestamp.
+     */
+    expiresAt?: number;
+}
+/** The sequence is terminal for this consumer. */
+export interface FanfareEndedDetail extends FanfareStateChangeBase {
+    /** Journey stage discriminator. */
+    stage: "routed";
+    /** Sequence phase discriminator. */
+    phase: "ended";
+    /** Distribution mechanism of the routed sequence. */
+    mechanism?: DistributionType;
+    /**
+     * Terminal outcome; the only arm that carries one.
+     *
+     * Carries the outcome type alone: the type is a closed picklist, while any
+     * accompanying qualifier is unbounded free text that a caller can supply, and
+     * this payload reaches every script on the page.
+     */
+    outcome: {
+        /** Terminal outcome type. */
+        type: SequenceOutcomeType;
+    };
+}
+/**
+ * `detail` of a {@link FANFARE_STATE_CHANGE_EVENT} event.
+ *
+ * Discriminated on `stage`, and within `routed` on `phase`, so a field only
+ * exists where it is meaningful: `outcome` on the ended arm, `expiresAt` on the
+ * granted and reserved arms, `position` on the participating queue arm. There
+ * is no arm for the absence of a journey — a payload is only ever built from a
+ * journey that exists.
+ */
+export type FanfareStateChangeDetail = FanfareReadyDetail | FanfareRoutingDetail | FanfareGatedDetail | FanfareUnavailableDetail | FanfareScheduledDetail | FanfareEnterableDetail | FanfareQueueParticipatingDetail | FanfareParticipatingDetail | FanfareSettlingDetail | FanfareReservedDetail | FanfareGrantedDetail | FanfareEndedDetail;
+/**
+ * The DOM event carrying a {@link FanfareStateChangeDetail}.
+ *
+ * Used to narrow inside a listener — `(e as FanfareStateChangeEvent).detail` —
+ * because no global event-map augmentation ships with this package.
+ */
+export type FanfareStateChangeEvent = CustomEvent<FanfareStateChangeDetail>;
+export {};

package/dist/bridge.js

@@ -0,0 +1,5 @@
+const E = "fanfare:state-change", t = 1;
+export {
+  t as BRIDGE_EVENT_VERSION,
+  E as FANFARE_STATE_CHANGE_EVENT
+};

package/dist/checkout.d.ts

@@ -0,0 +1,177 @@
+import { InferInput, InferOutput } from 'valibot';
+import * as v from "valibot";
+export declare const MoneyStringSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.number">]>;
+export declare const CurrencyCodeSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.pattern">]>;
+/**
+ * How Fanfare handles payment for a distribution's winners.
+ *
+ * Omitted (or `undefined` on the wire) means `"merchant"` — the default: the
+ * merchant's own checkout collects payment after admission, outside Fanfare's purview.
+ */
+export declare const DistributionCheckoutMode: {
+    readonly MERCHANT: "merchant";
+    readonly PRE_AUTH: "pre_auth";
+    readonly POST_WIN: "post_win";
+};
+export declare const DistributionCheckoutModes: readonly ["merchant", "pre_auth", "post_win"];
+export type DistributionCheckoutMode = (typeof DistributionCheckoutModes)[number];
+export declare const DistributionCheckoutModeSchema: v.PicklistSchema<readonly ["merchant", "pre_auth", "post_win"], undefined>;
+/**
+ * Who executes the payment leg for a distribution. Orthogonal to `DistributionCheckoutMode`,
+ * which says WHEN settlement happens relative to winning; this says WHO moves the money.
+ * Fanfare's own processor is the only value today. A processor that hands the consumer off to
+ * an external checkout adds a value here and an arm to every discriminated union keyed on it —
+ * processor-specific fields are never hoisted alongside another processor's.
+ */
+export declare const CheckoutProcessor: {
+    readonly INTERNAL: "internal";
+};
+export declare const CheckoutProcessors: readonly ["internal"];
+export type CheckoutProcessor = (typeof CheckoutProcessors)[number];
+export declare const CheckoutProcessorSchema: v.PicklistSchema<readonly ["internal"], undefined>;
+/**
+ * What the client must do to finish a payment the processor paused (a bank authentication
+ * challenge). Discriminated by processor: the `internal` arm carries the payment-intent client
+ * secret the browser hands to Stripe.js; another processor would carry its own hand-off shape.
+ * Never flatten an arm's fields onto a carrier — callers narrow on `processor` first.
+ */
+export declare const CheckoutNextActionSchema: v.VariantSchema<"processor", [v.ObjectSchema<{
+    readonly processor: v.LiteralSchema<"internal", undefined>;
+    readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>], undefined>;
+export type CheckoutNextAction = InferOutput<typeof CheckoutNextActionSchema>;
+/**
+ * The client-side configuration Fanfare's internal processor needs in the browser: the
+ * publishable key that identifies the platform account, and the connected account a Connect
+ * direct charge runs on when one applies.
+ *
+ * The processor discriminator is the affordance's own `processor` field and the distribution's
+ * checkout mode — never this block's presence: on a checkout-capable arm an absent block can
+ * only mean the configuration read failed, and the client must render retryable payment
+ * unavailability, not infer a different processor. A merchant-mode view carries no payment
+ * affordance at all. Nothing here is a secret: a publishable key and an account id are client-visible by
+ * design. No secret key, no client secret, and no payment-intent id ever belongs in this block.
+ */
+export declare const PaymentProviderConfigSchema: v.ObjectSchema<{
+    readonly publishableKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly stripeAccount: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+}, undefined>;
+export type PaymentProviderConfig = InferOutput<typeof PaymentProviderConfigSchema>;
+/**
+ * Alternative body a `pre_auth` distribution-entry call returns when the processor paused the
+ * authorization pending an out-of-band action. Entry is fail-closed: this response means the
+ * consumer is NOT in the distribution. Completing the action and re-submitting the same entry
+ * call resolves it; entry authorization is idempotent per (organization, consumer, distribution).
+ */
+export declare const DistributionEntryRequiresActionSchema: v.ObjectSchema<{
+    readonly outcome: v.LiteralSchema<"requires_action", undefined>;
+    readonly nextAction: v.VariantSchema<"processor", [v.ObjectSchema<{
+        readonly processor: v.LiteralSchema<"internal", undefined>;
+        readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>], undefined>;
+}, undefined>;
+export type DistributionEntryRequiresAction = InferOutput<typeof DistributionEntryRequiresActionSchema>;
+export declare const PaymentInputSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"saved", undefined>;
+    readonly paymentMethodId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"new", undefined>;
+    readonly stripePaymentMethodId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>], undefined>;
+export type PaymentInput = InferInput<typeof PaymentInputSchema>;
+export declare const PaymentMethodSummarySchema: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly brand: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly last4: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 4, undefined>]>;
+    readonly expiryMonth: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 12, undefined>]>;
+    readonly expiryYear: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 2000, undefined>]>;
+    readonly isDefault: v.BooleanSchema<undefined>;
+}, undefined>;
+export type PaymentMethodSummary = InferOutput<typeof PaymentMethodSummarySchema>;
+/**
+ * Fanfare's receipt for a payment it captured directly (`pre_auth`/`post_win` modes).
+ * Carried on the successful sequence variant so the consumer surface can render a receipt
+ * without a second round-trip. `amount` stays a string — money is never a float on the wire.
+ */
+export declare const FanfareCheckoutResultSchema: v.ObjectSchema<{
+    readonly orderId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly amount: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.number">]>;
+    readonly currencyCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.pattern">]>;
+    readonly paymentMethodLast4: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 4, undefined>]>, undefined>;
+    readonly paymentMethodBrand: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+}, undefined>;
+export type FanfareCheckoutResult = InferOutput<typeof FanfareCheckoutResultSchema>;
+export declare const ReservationCheckoutOutcomes: readonly ["completed", "requires_action"];
+export type ReservationCheckoutOutcome = (typeof ReservationCheckoutOutcomes)[number];
+/**
+ * A reservation checkout that finished: the payment settled and produced an order. The order
+ * reference IS the outcome — paying a post-win window ends the journey rather than issuing
+ * admission, so there is deliberately no credential here to mint or to carry.
+ */
+export declare const ReservationCheckoutCompletedSchema: v.ObjectSchema<{
+    readonly outcome: v.LiteralSchema<"completed", undefined>;
+    readonly checkout: v.ObjectSchema<{
+        readonly orderId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly amount: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.number">]>;
+        readonly currencyCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.pattern">]>;
+        readonly paymentMethodLast4: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 4, undefined>]>, undefined>;
+        readonly paymentMethodBrand: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type ReservationCheckoutCompleted = InferOutput<typeof ReservationCheckoutCompletedSchema>;
+/**
+ * A reservation checkout the processor paused pending an out-of-band action. The reservation is
+ * still live and still owns its own deadline; completing the action and re-submitting the SAME
+ * confirm resolves it — the server is idempotent, so a retry never produces a second order.
+ */
+export declare const ReservationCheckoutRequiresActionSchema: v.ObjectSchema<{
+    readonly outcome: v.LiteralSchema<"requires_action", undefined>;
+    readonly nextAction: v.VariantSchema<"processor", [v.ObjectSchema<{
+        readonly processor: v.LiteralSchema<"internal", undefined>;
+        readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>], undefined>;
+}, undefined>;
+export type ReservationCheckoutRequiresAction = InferOutput<typeof ReservationCheckoutRequiresActionSchema>;
+/** Response to confirming checkout on a `post_win` reservation, discriminated on `outcome`. */
+export declare const ReservationCheckoutResponseSchema: v.VariantSchema<"outcome", [v.ObjectSchema<{
+    readonly outcome: v.LiteralSchema<"completed", undefined>;
+    readonly checkout: v.ObjectSchema<{
+        readonly orderId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly amount: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.number">]>;
+        readonly currencyCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "validation.pattern">]>;
+        readonly paymentMethodLast4: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 4, undefined>]>, undefined>;
+        readonly paymentMethodBrand: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly outcome: v.LiteralSchema<"requires_action", undefined>;
+    readonly nextAction: v.VariantSchema<"processor", [v.ObjectSchema<{
+        readonly processor: v.LiteralSchema<"internal", undefined>;
+        readonly clientSecret: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>], undefined>;
+}, undefined>], undefined>;
+export type ReservationCheckoutResponse = InferOutput<typeof ReservationCheckoutResponseSchema>;
+export declare const PaymentMethodsListResponseSchema: v.ObjectSchema<{
+    readonly paymentMethods: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly brand: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly last4: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 4, undefined>]>;
+        readonly expiryMonth: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 12, undefined>]>;
+        readonly expiryYear: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 2000, undefined>]>;
+        readonly isDefault: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type PaymentMethodsListResponse = InferOutput<typeof PaymentMethodsListResponseSchema>;
+export declare const AddPaymentMethodRequestSchema: v.ObjectSchema<{
+    readonly stripePaymentMethodId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
+export type AddPaymentMethodRequest = InferInput<typeof AddPaymentMethodRequestSchema>;
+/** Response to adding a payment method — reuses {@link PaymentMethodSummarySchema} directly. */
+export declare const AddPaymentMethodResponseSchema: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly brand: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly last4: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 4, undefined>]>;
+    readonly expiryMonth: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 12, undefined>]>;
+    readonly expiryYear: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 2000, undefined>]>;
+    readonly isDefault: v.BooleanSchema<undefined>;
+}, undefined>;
+export type AddPaymentMethodResponse = InferOutput<typeof AddPaymentMethodResponseSchema>;

package/dist/checkout.js

@@ -0,0 +1,81 @@
+import * as e from "valibot";
+const t = e.string(), a = e.pipe(t, e.regex(/^\d{1,12}(\.\d{1,8})?$/, "validation.number")), r = e.pipe(t, e.regex(/^[A-Z]{3}$/, "validation.pattern")), o = {
+  MERCHANT: "merchant",
+  PRE_AUTH: "pre_auth",
+  POST_WIN: "post_win"
+}, s = [
+  o.MERCHANT,
+  o.PRE_AUTH,
+  o.POST_WIN
+], d = e.picklist(s), n = {
+  INTERNAL: "internal"
+}, p = [n.INTERNAL], l = e.picklist(p), i = e.variant("processor", [
+  e.object({
+    processor: e.literal(n.INTERNAL),
+    clientSecret: e.pipe(t, e.minLength(1))
+  })
+]), y = e.object({
+  publishableKey: e.pipe(t, e.minLength(1)),
+  stripeAccount: e.optional(e.pipe(t, e.minLength(1)))
+}), S = e.object({
+  outcome: e.literal("requires_action"),
+  nextAction: i
+}), b = e.variant("type", [
+  e.object({
+    type: e.literal("saved"),
+    paymentMethodId: e.pipe(t, e.minLength(1))
+  }),
+  e.object({
+    type: e.literal("new"),
+    stripePaymentMethodId: e.pipe(t, e.minLength(1))
+  })
+]), c = e.object({
+  id: e.pipe(t, e.minLength(1)),
+  brand: e.pipe(t, e.minLength(1)),
+  last4: e.pipe(t, e.length(4)),
+  expiryMonth: e.pipe(e.number(), e.integer(), e.minValue(1), e.maxValue(12)),
+  expiryYear: e.pipe(e.number(), e.integer(), e.minValue(2e3)),
+  isDefault: e.boolean()
+}), m = e.object({
+  orderId: e.pipe(t, e.minLength(1)),
+  amount: a,
+  currencyCode: r,
+  paymentMethodLast4: e.optional(e.pipe(t, e.length(4))),
+  paymentMethodBrand: e.optional(e.pipe(t, e.minLength(1)))
+}), g = ["completed", "requires_action"], h = e.object({
+  outcome: e.literal("completed"),
+  checkout: m
+}), u = e.object({
+  outcome: e.literal("requires_action"),
+  nextAction: i
+}), C = e.variant("outcome", [
+  h,
+  u
+]), R = e.object({
+  paymentMethods: e.array(c)
+}), M = e.object({
+  stripePaymentMethodId: e.pipe(t, e.minLength(1))
+}), A = c;
+export {
+  M as AddPaymentMethodRequestSchema,
+  A as AddPaymentMethodResponseSchema,
+  i as CheckoutNextActionSchema,
+  n as CheckoutProcessor,
+  l as CheckoutProcessorSchema,
+  p as CheckoutProcessors,
+  r as CurrencyCodeSchema,
+  o as DistributionCheckoutMode,
+  d as DistributionCheckoutModeSchema,
+  s as DistributionCheckoutModes,
+  S as DistributionEntryRequiresActionSchema,
+  m as FanfareCheckoutResultSchema,
+  a as MoneyStringSchema,
+  b as PaymentInputSchema,
+  c as PaymentMethodSummarySchema,
+  R as PaymentMethodsListResponseSchema,
+  y as PaymentProviderConfigSchema,
+  h as ReservationCheckoutCompletedSchema,
+  g as ReservationCheckoutOutcomes,
+  u as ReservationCheckoutRequiresActionSchema,
+  C as ReservationCheckoutResponseSchema
+};