@fun-xyz/fiat-contract 0.22.2 → 0.24.0

package/dist/index.js

@@ -42,7 +42,14 @@ __export(index_exports, {
   FiatAmountSchema: () => FiatAmountSchema,
   FiatCurrencyCode: () => FiatCurrencyCode,
   FiatEndpointSchema: () => FiatEndpointSchema,
+  FiatGeoSchema: () => FiatGeoSchema,
+  FiatNextRequestSchema: () => FiatNextRequestSchema,
   FiatProviderSchema: () => FiatProviderSchema,
+  FiatRoutingQuoteErrorBodySchema: () => FiatRoutingQuoteErrorBodySchema,
+  FiatRoutingQuoteRequestSchema: () => FiatRoutingQuoteRequestSchema,
+  FiatRoutingTableErrorBodySchema: () => FiatRoutingTableErrorBodySchema,
+  FiatRoutingTableQuerySchema: () => FiatRoutingTableQuerySchema,
+  FiatRoutingTableResponseSchema: () => FiatRoutingTableResponseSchema,
   FiatStepResponseSchema: () => FiatStepResponseSchema,
   FiatTermsErrorBodySchema: () => FiatTermsErrorBodySchema,
   FiatTermsRequestSchema: () => FiatTermsRequestSchema,
@@ -67,14 +74,28 @@ __export(index_exports, {
   KycSdkResultReportSchema: () => KycSdkResultReportSchema,
   MOONPAY_ENDPOINTS: () => MOONPAY_ENDPOINTS,
   MoonPayCheckoutSchema: () => MoonPayCheckoutSchema,
+  MoonPayConnectPromptSchema: () => MoonPayConnectPromptSchema,
+  MoonPayConnectRequestSchema: () => MoonPayConnectRequestSchema,
+  MoonPayConsentPromptSchema: () => MoonPayConsentPromptSchema,
+  MoonPayConsentRequestSchema: () => MoonPayConsentRequestSchema,
+  MoonPayDoneSchema: () => MoonPayDoneSchema,
   MoonPayErrorBodySchema: () => MoonPayErrorBodySchema,
   MoonPayFaultSchema: () => MoonPayFaultSchema,
-  MoonPayIntentRequestSchema: () => MoonPayIntentRequestSchema,
-  MoonPayIntentResponseSchema: () => MoonPayIntentResponseSchema,
+  MoonPayKycPromptSchema: () => MoonPayKycPromptSchema,
+  MoonPayKycRequestSchema: () => MoonPayKycRequestSchema,
+  MoonPayNextRequestSchema: () => MoonPayNextRequestSchema,
+  MoonPayObserveRequestSchema: () => MoonPayObserveRequestSchema,
+  MoonPayOrderPromptSchema: () => MoonPayOrderPromptSchema,
+  MoonPayOrderRequestSchema: () => MoonPayOrderRequestSchema,
   MoonPayOrderResponseSchema: () => MoonPayOrderResponseSchema,
+  MoonPayPromptSchema: () => MoonPayPromptSchema,
   MoonPayQuoteInputSchema: () => MoonPayQuoteInputSchema,
+  MoonPayRequestContextSchema: () => MoonPayRequestContextSchema,
+  MoonPayRequestSchema: () => MoonPayRequestSchema,
+  MoonPayResponseSchemaFor: () => MoonPayResponseSchemaFor,
   MoonPaySdkCredentialsSchema: () => MoonPaySdkCredentialsSchema,
   MoonPayStepResponseSchema: () => MoonPayStepResponseSchema,
+  MoonPayWaitPromptSchema: () => MoonPayWaitPromptSchema,
   OrderAwaitingConfirmationStateSchema: () => OrderAwaitingConfirmationStateSchema,
   OrderCreatedStateSchema: () => OrderCreatedStateSchema,
   OrderRefSchema: () => OrderRefSchema,
@@ -94,6 +115,7 @@ __export(index_exports, {
   QuoteLimitsSchema: () => QuoteLimitsSchema,
   QuoteSchema: () => QuoteSchema,
   QuoteStateSchema: () => QuoteStateSchema,
+  ROUTING_ENDPOINTS: () => ROUTING_ENDPOINTS,
   RecoverySchema: () => RecoverySchema,
   RefundSchema: () => RefundSchema,
   ReportSpecSchema: () => ReportSpecSchema,
@@ -975,6 +997,8 @@ var $providerBoundFlowState = import_zod.z.union([
 var $flowState = import_zod.z.union([$providerBoundFlowState, $blockedState]);
 var FlowStateSchema = $flowState;
 var $nonBlank = import_zod.z.string().refine((value) => value.trim().length > 0, "must not be blank");
+var $isoInstant = import_zod.z.string().datetime({ offset: true });
+var $errorBodyFields = { errorMsg: import_zod.z.string(), reqId: import_zod.z.string().optional() };
 var $termsStage = import_zod.z.enum(["CHECKOUT", "KYC"]);
 var $termsDocument = obj({
   id: $nonBlank,
@@ -990,7 +1014,7 @@ var $termsAcceptance = obj({
   documentId: $nonBlank,
   version: $nonBlank,
   contentDigest: $nonBlank,
-  acceptedAt: import_zod.z.string().datetime({ offset: true })
+  acceptedAt: $isoInstant
 });
 var TermsDocumentAcceptanceSchema = $termsAcceptance;
 var $termsRequest = obj({
@@ -1002,12 +1026,121 @@ var $termsResponse = obj({ recorded: import_zod.z.array($nonBlank) });
 var FiatTermsResponseSchema = $termsResponse;
 var $termsErrorBody = obj({
   errorCode: $nonBlank,
-  errorMsg: import_zod.z.string(),
-  reqId: import_zod.z.string().optional(),
+  ...$errorBodyFields,
   reason: import_zod.z.enum(["STALE_TERMS", "INVALID_REQUEST", "RATE_LIMITED", "PROVIDER_UNAVAILABLE"]),
   recovery: import_zod.z.enum(["RETRY", "REQUOTE", "NONE"])
 });
 var FiatTermsErrorBodySchema = $termsErrorBody;
+var $decimalAmount = import_zod.z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d+)?$/, "must be a decimal string");
+var compareDecimals = (left, right) => {
+  const [leftWhole = "", leftFraction = ""] = left.split(".");
+  const [rightWhole = "", rightFraction = ""] = right.split(".");
+  if (leftWhole.length !== rightWhole.length) return leftWhole.length - rightWhole.length;
+  const width = Math.max(leftFraction.length, rightFraction.length);
+  const leftDigits = leftWhole + leftFraction.padEnd(width, "0");
+  const rightDigits = rightWhole + rightFraction.padEnd(width, "0");
+  return leftDigits < rightDigits ? -1 : leftDigits > rightDigits ? 1 : 0;
+};
+var $countryCode = import_zod.z.enum(Object.keys(CountryCode));
+var $routingProvider = $provider.extract(["TRANSAK", "BANXA", "MOONPAY", "STRIPE", "COINBASE"]);
+var $optionalGeoField = import_zod.z.union([$nonBlank, import_zod.z.literal("")]).optional();
+var US_REGION_REQUIRED = "a US buyer needs a US state code as region";
+var hasUsRegion = (country, region) => country !== "US" || UsStateCodeSchema.safeParse(region).success;
+var $routingTableQuery = obj({
+  fiatCurrencyCode: import_zod.z.enum(FIAT_CURRENCY_CODES).optional(),
+  cryptoCurrencyCode: $nonBlank,
+  chainId: $nonBlank,
+  country: $countryCode,
+  region: $optionalGeoField,
+  methods: import_zod.z.string().refine(
+    (methods) => methods.split(",").every((method) => PAYMENT_METHOD_CATEGORIES.includes(method.trim())),
+    "must be comma-separated payment method categories"
+  )
+}).refine((query) => hasUsRegion(query.country, query.region), { message: US_REGION_REQUIRED, path: ["region"] });
+var FiatRoutingTableQuerySchema = $routingTableQuery;
+var $routingTableProvider = obj({
+  provider: $routingProvider,
+  next: import_zod.z.enum(["READY", "AUTH", "DECLARATIVE_KYC", "DOCUMENTARY_KYC", "PENDING_REVIEW"]),
+  visibility: import_zod.z.enum(["COMPLETE", "PARTIAL", "AUTH_GATED"])
+});
+var $routingTableInterval = obj({
+  min: $decimalAmount,
+  max: $decimalAmount,
+  providers: import_zod.z.array($routingTableProvider).min(1).refine((providers) => hasUniqueIds(providers.map((entry) => entry.provider)), "each provider is listed once")
+}).refine((interval) => compareDecimals(interval.min, interval.max) <= 0, { message: "min must not exceed max", path: ["max"] });
+var $routingTableMethod = obj({
+  method: import_zod.z.enum(PAYMENT_METHOD_CATEGORIES),
+  unavailableReason: import_zod.z.enum(["USER_LIMIT", "KYC_REJECTED", "PROVIDER_OUTAGE", "NOT_SERVED"]).optional(),
+  intervals: import_zod.z.array($routingTableInterval).superRefine((intervals, context) => {
+    intervals.forEach((interval, index) => {
+      const previous = intervals[index - 1];
+      if (previous !== void 0 && compareDecimals(interval.min, previous.max) <= 0) {
+        context.addIssue({ code: "custom", path: [index, "min"], message: "intervals are sorted and do not overlap" });
+      }
+    });
+  })
+}).refine((method) => method.unavailableReason === void 0 || method.intervals.length === 0, {
+  message: "unavailableReason only with no interval",
+  path: ["unavailableReason"]
+});
+var $routingTableResponse = obj({
+  expiresAt: $isoInstant,
+  methods: import_zod.z.array($routingTableMethod).refine((methods) => hasUniqueIds(methods.map((entry) => entry.method)), "each method is listed once")
+});
+var FiatRoutingTableResponseSchema = $routingTableResponse;
+var $routingQuoteRequest = obj({
+  provider: $routingProvider,
+  fiatCurrency: import_zod.z.enum(FIAT_CURRENCY_CODES),
+  fiatAmount: $decimalAmount.refine((amount) => Number(amount) > 0, "must be positive"),
+  cryptoCurrencyCode: $nonBlank,
+  chainId: $nonBlank,
+  paymentMethodId: import_zod.z.enum(PAYMENT_METHOD_CATEGORIES),
+  geo: obj({ alpha2: $countryCode, region: $optionalGeoField, ip: $optionalGeoField, city: import_zod.z.string().optional() }).refine(
+    (geo) => hasUsRegion(geo.alpha2, geo.region),
+    { message: US_REGION_REQUIRED, path: ["region"] }
+  ),
+  prepareSessionAuth: import_zod.z.boolean().optional()
+});
+var FiatRoutingQuoteRequestSchema = $routingQuoteRequest;
+var $routingServiceableRange = obj({ min: $money, max: $money, userMax: $money.nullable().optional() });
+var $noRouteFields = {
+  ...$errorBodyFields,
+  errorCode: import_zod.z.literal("FiatNoRouteError"),
+  serviceableRanges: import_zod.z.array($routingServiceableRange),
+  retryable: import_zod.z.boolean()
+};
+var $routingNoRouteErrorBody = import_zod.z.union([
+  obj({ ...$noRouteFields, reason: import_zod.z.enum(["NO_CANDIDATE", "PROVIDER_DECLINED", "PROVIDER_OUTAGE", "KYC_REJECTED"]) }),
+  obj({ ...$noRouteFields, reason: import_zod.z.literal("USER_LIMIT"), code: import_zod.z.literal("LIMITS_EXCEEDED"), recovery: import_zod.z.literal("REQUOTE") })
+]);
+var $amountErrorFields = { ...$errorBodyFields, fiatCurrencyCode: import_zod.z.enum(FIAT_CURRENCY_CODES) };
+var $routingAmountErrorBody = import_zod.z.union([
+  obj({ ...$amountErrorFields, errorCode: import_zod.z.literal("FiatAmountBelowMinimumError"), minFiatAmount: $decimalAmount }),
+  obj({ ...$amountErrorFields, errorCode: import_zod.z.literal("FiatAmountAboveMaximumError"), maxFiatAmount: $decimalAmount })
+]);
+var $routingRateLimitedErrorBody = obj({
+  ...$errorBodyFields,
+  errorCode: import_zod.z.literal("TooManyRequestsError"),
+  retryAfterSeconds: import_zod.z.number().int().positive().optional()
+});
+var ROUTING_ERROR_CODES = [
+  "FiatNoRouteError",
+  "FiatAmountBelowMinimumError",
+  "FiatAmountAboveMaximumError",
+  "TooManyRequestsError"
+];
+var $routingFaultErrorBody = obj({
+  ...$errorBodyFields,
+  errorCode: $nonBlank.refine((code) => !ROUTING_ERROR_CODES.includes(code), "this errorCode carries its own fields")
+});
+var $routingTableErrorBody = import_zod.z.union([$routingRateLimitedErrorBody, $routingFaultErrorBody]);
+var FiatRoutingTableErrorBodySchema = $routingTableErrorBody;
+var $routingQuoteErrorBody = import_zod.z.union([$routingNoRouteErrorBody, $routingAmountErrorBody, $routingFaultErrorBody]);
+var FiatRoutingQuoteErrorBodySchema = $routingQuoteErrorBody;
+var $fiatGeo = obj({ alpha2: import_zod.z.string().regex(/^[A-Z]{2}$/), region: $nonBlank.optional(), ip: $nonBlank.optional() });
+var FiatGeoSchema = $fiatGeo;
+var $nextRequest = import_zod.z.object({ provider: $provider, action: $nonBlank, geo: $fiatGeo }).catchall(import_zod.z.unknown());
+var FiatNextRequestSchema = $nextRequest;
 var $providerBoundStepResponse = obj({
   state: $providerBoundFlowState,
   provider: $provider,
@@ -1067,7 +1200,7 @@ var $stepResponse = import_zod.z.union([$providerBoundStepResponse, $blockedStep
 var FiatStepResponseSchema = $stepResponse;
 
 // package.json
-var version = "0.22.2";
+var version = "0.24.0";
 
 // src/table.ts
 var TABLE_VERSION = version;
@@ -2670,9 +2803,16 @@ var FUN_KYC_CONSENT_DOCUMENTS = {
 };
 var PUBLISHED_TERMS_DOCUMENTS = [MOONPAY_TERMS, ...Object.values(FUN_KYC_CONSENT_DOCUMENTS)];
 
+// src/routing.ts
+var ROUTING_ENDPOINTS = {
+  table: "GET /fiat/routing/table",
+  /** Temporary: `POST /fiat/next` replaces it for each provider that moves there. */
+  quote: "POST /fiat/routing/quote"
+};
+
 // src/providers/moonpay.ts
 var MOONPAY_ENDPOINTS = {
-  intent: "POST /fiat/providers/moonpay/intent"
+  next: "POST /fiat/next"
 };
 
 // src/providers/moonpay.schemas.ts
@@ -2681,33 +2821,17 @@ var FIAT_CURRENCY_CODES2 = Object.keys(FIAT_CURRENCY_NAMES);
 var obj2 = (shape) => import_zod2.z.object(shape).strict();
 var $nonEmpty = import_zod2.z.string().refine((value) => value.trim().length > 0, "must not be blank");
 var hasUniqueIds2 = (ids) => new Set(ids).size === ids.length;
-var $geo = obj2({ alpha2: import_zod2.z.string().regex(/^[A-Z]{2}$/), region: $nonEmpty.optional(), ip: $nonEmpty.optional() });
 var $checkout = obj2({
   amount: FiatAmountSchema,
   destination: obj2({ asset: $nonEmpty, network: $nonEmpty }),
-  paymentMethod: import_zod2.z.literal("apple_pay"),
-  geo: $geo
+  paymentMethod: import_zod2.z.literal("apple_pay")
 });
 var MoonPayCheckoutSchema = $checkout;
 var $credentials = obj2({ customerId: $nonEmpty, accessToken: $nonEmpty });
 var MoonPaySdkCredentialsSchema = $credentials;
-var $intentRequest = import_zod2.z.discriminatedUnion("kind", [
-  obj2({ kind: import_zod2.z.literal("observe"), checkout: $checkout, credentials: $credentials.optional() }),
-  obj2({
-    kind: import_zod2.z.literal("kyc"),
-    checkout: $checkout,
-    credentials: $credentials,
-    values: import_zod2.z.record(KycFieldIdSchema, import_zod2.z.string()).refine((values) => Object.keys(values).length > 0, "values must not be empty")
-  }),
-  obj2({
-    kind: import_zod2.z.literal("order"),
-    orderId: $nonEmpty,
-    transactionId: $nonEmpty.optional(),
-    quotedAmount: FiatAmountSchema,
-    geo: $geo.optional()
-  })
-]);
-var MoonPayIntentRequestSchema = $intentRequest;
+var $context = { checkout: $checkout, credentials: $credentials.optional() };
+var $requestContext = obj2($context);
+var MoonPayRequestContextSchema = $requestContext;
 var $quoteInput = obj2({
   source: obj2({ asset: obj2({ code: import_zod2.z.enum(FIAT_CURRENCY_CODES2) }), amount: $nonEmpty }),
   destination: obj2({ asset: obj2({ code: $nonEmpty }) }),
@@ -2716,50 +2840,103 @@ var $quoteInput = obj2({
   feeBehavior: import_zod2.z.literal("inclusive")
 });
 var MoonPayQuoteInputSchema = $quoteInput;
-var $stepRefusal = import_zod2.z.enum(["NOT_ELIGIBLE", "DOCUMENTS_REQUIRED", "FINAL_REJECTION", "CUSTOMER_MISMATCH"]);
-var $orderRefusal = import_zod2.z.enum(["CUSTOMER_MISMATCH", "WALLET_MISMATCH", "UNRECORDABLE"]);
+var $observeFields = { action: import_zod2.z.literal("observe") };
+var $consentFields = {
+  action: import_zod2.z.literal("consent"),
+  acceptances: import_zod2.z.array(TermsDocumentAcceptanceSchema).min(1).refine((acceptances) => hasUniqueIds2(acceptances.map((acceptance) => acceptance.documentId)), "each document is accepted once")
+};
+var $connectFields = { action: import_zod2.z.literal("connect"), customerId: $nonEmpty, accessToken: $nonEmpty };
+var $kycFields = {
+  action: import_zod2.z.literal("kyc"),
+  credentials: $credentials,
+  values: import_zod2.z.record(KycFieldIdSchema, import_zod2.z.string()).refine((values) => Object.keys(values).length > 0, "values must not be empty")
+};
+var $orderFields = { action: import_zod2.z.literal("order"), orderId: $nonEmpty, quotedAmount: FiatAmountSchema, transactionId: $nonEmpty.optional() };
+var $observeRequest = obj2({ ...$context, ...$observeFields });
+var $consentRequest = obj2({ ...$context, ...$consentFields });
+var $connectRequest = obj2({ ...$context, ...$connectFields });
+var $kycRequest = obj2({ ...$context, ...$kycFields });
+var $orderRequest = obj2({ ...$context, ...$orderFields });
+var MoonPayObserveRequestSchema = $observeRequest;
+var MoonPayConsentRequestSchema = $consentRequest;
+var MoonPayConnectRequestSchema = $connectRequest;
+var MoonPayKycRequestSchema = $kycRequest;
+var MoonPayOrderRequestSchema = $orderRequest;
+var $request = import_zod2.z.discriminatedUnion("action", [$observeRequest, $consentRequest, $connectRequest, $kycRequest, $orderRequest]);
+var MoonPayRequestSchema = $request;
+var $envelope = { provider: import_zod2.z.literal("MOONPAY"), geo: FiatGeoSchema, ...$context };
+var $nextRequest2 = import_zod2.z.discriminatedUnion("action", [
+  obj2({ ...$envelope, ...$observeFields }),
+  obj2({ ...$envelope, ...$consentFields }),
+  obj2({ ...$envelope, ...$connectFields }),
+  obj2({ ...$envelope, ...$kycFields }),
+  obj2({ ...$envelope, ...$orderFields })
+]);
+var MoonPayNextRequestSchema = $nextRequest2;
 var FIELD_OF_CODE = { PHONE_IN_USE: "PHONE_NUMBER", TAX_ID_IN_USE: "TAX_IDENTIFIER" };
 var $fieldError = obj2({ fieldId: $nonEmpty, message: $nonEmpty, code: import_zod2.z.enum(["PHONE_IN_USE", "TAX_ID_IN_USE"]).optional() });
-var $pending = obj2({ status: import_zod2.z.literal("PENDING"), retryAfterMs: import_zod2.z.number().int().positive().max(6e4) });
-var $stepStatus = import_zod2.z.discriminatedUnion("status", [
-  obj2({ status: import_zod2.z.literal("TERMS"), stage: import_zod2.z.enum(["CHECKOUT", "KYC"]), documents: import_zod2.z.array(TermsDocumentSchema).min(1) }),
-  obj2({ status: import_zod2.z.literal("SDK_AUTH"), sessionToken: $nonEmpty, quoteInput: $quoteInput, resetConnection: import_zod2.z.literal(true).optional() }),
-  obj2({ status: import_zod2.z.literal("KYC"), fields: import_zod2.z.array(FormFieldSchema).min(1), fieldErrors: import_zod2.z.array($fieldError).min(1).optional() }),
-  $pending,
-  obj2({ status: import_zod2.z.literal("READY"), orderId: $nonEmpty, quoteInput: $quoteInput }),
-  obj2({ status: import_zod2.z.literal("REFUSED"), reason: $stepRefusal, recovery: import_zod2.z.enum(["REQUOTE", "NONE"]) })
-]);
-var $stepResponse2 = $stepStatus.superRefine((response, context) => {
-  if (response.status === "TERMS") {
-    if (!hasUniqueIds2(response.documents.map((document) => document.id))) {
-      context.addIssue({ code: "custom", path: ["documents"], message: "document ids must be unique" });
-    }
-    if (response.documents.some((document) => document.stage !== response.stage)) {
-      context.addIssue({ code: "custom", path: ["documents"], message: "every document must be at the response stage" });
-    }
+var $consentShape = obj2({ next: import_zod2.z.literal("consent"), documents: import_zod2.z.array(TermsDocumentSchema).min(1) });
+var $connectPrompt = obj2({
+  next: import_zod2.z.literal("connect"),
+  sessionToken: $nonEmpty,
+  quoteInput: $quoteInput,
+  resetConnection: import_zod2.z.literal(true).optional()
+});
+var $kycShape = obj2({ next: import_zod2.z.literal("kyc"), fields: import_zod2.z.array(FormFieldSchema).min(1), fieldErrors: import_zod2.z.array($fieldError).min(1).optional() });
+var $waitPrompt = obj2({ next: import_zod2.z.literal("wait"), retryAfterMs: import_zod2.z.number().int().positive().max(6e4) });
+var $orderPrompt = obj2({ next: import_zod2.z.literal("order"), orderId: $nonEmpty, quoteInput: $quoteInput });
+var checkConsent = (prompt, context) => {
+  if (!hasUniqueIds2(prompt.documents.map((document) => document.id))) {
+    context.addIssue({ code: "custom", path: ["documents"], message: "document ids must be unique" });
   }
-  if (response.status === "KYC") {
-    const fieldIds = response.fields.map((field) => field.id);
-    if (!hasUniqueIds2(fieldIds)) {
-      context.addIssue({ code: "custom", path: ["fields"], message: "field ids must be unique" });
-    }
-    if (response.fieldErrors?.some((error) => !fieldIds.includes(error.fieldId))) {
-      context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error must name a field in this response" });
-    }
-    if (response.fieldErrors?.some((error) => error.code && FIELD_OF_CODE[error.code] !== error.fieldId)) {
-      context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error code must match its field" });
-    }
+};
+var checkKyc = (prompt, context) => {
+  const fieldIds = prompt.fields.map((field) => field.id);
+  if (!hasUniqueIds2(fieldIds)) {
+    context.addIssue({ code: "custom", path: ["fields"], message: "field ids must be unique" });
+  }
+  if (prompt.fieldErrors?.some((error) => !fieldIds.includes(error.fieldId))) {
+    context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error must name a field in this prompt" });
   }
+  if (prompt.fieldErrors?.some((error) => error.code && FIELD_OF_CODE[error.code] !== error.fieldId)) {
+    context.addIssue({ code: "custom", path: ["fieldErrors"], message: "a field error code must match its field" });
+  }
+};
+var MoonPayConsentPromptSchema = $consentShape.superRefine(checkConsent);
+var MoonPayConnectPromptSchema = $connectPrompt;
+var MoonPayKycPromptSchema = $kycShape.superRefine(checkKyc);
+var MoonPayWaitPromptSchema = $waitPrompt;
+var MoonPayOrderPromptSchema = $orderPrompt;
+var checkPrompt = (response, context) => {
+  if (response.next === "consent") checkConsent(response, context);
+  if (response.next === "kyc") checkKyc(response, context);
+};
+var $promptOptions = [$consentShape, $connectPrompt, $kycShape, $waitPrompt, $orderPrompt];
+var $prompt = import_zod2.z.discriminatedUnion("next", [...$promptOptions]).superRefine(checkPrompt);
+var MoonPayPromptSchema = $prompt;
+var $done = obj2({ next: import_zod2.z.literal("done"), order: FiatStepResponseSchema });
+var MoonPayDoneSchema = $done;
+var $stepRefused = obj2({
+  next: import_zod2.z.literal("refused"),
+  reason: import_zod2.z.enum(["NOT_ELIGIBLE", "DOCUMENTS_REQUIRED", "FINAL_REJECTION", "CUSTOMER_MISMATCH"]),
+  recovery: import_zod2.z.enum(["REQUOTE", "NONE"])
+});
+var $orderRefused = obj2({
+  next: import_zod2.z.literal("refused"),
+  reason: import_zod2.z.enum(["CUSTOMER_MISMATCH", "WALLET_MISMATCH", "UNRECORDABLE"]),
+  recovery: import_zod2.z.literal("NONE")
 });
+var $stepResponse2 = import_zod2.z.discriminatedUnion("next", [...$promptOptions, $stepRefused]).superRefine(checkPrompt);
 var MoonPayStepResponseSchema = $stepResponse2;
-var $orderResponse = import_zod2.z.discriminatedUnion("status", [
-  obj2({ status: import_zod2.z.literal("DONE"), order: FiatStepResponseSchema }),
-  $pending,
-  obj2({ status: import_zod2.z.literal("REFUSED"), reason: $orderRefusal, recovery: import_zod2.z.literal("NONE") })
-]);
+var $orderResponse = import_zod2.z.discriminatedUnion("next", [$done, $orderPrompt, $orderRefused]);
 var MoonPayOrderResponseSchema = $orderResponse;
-var $intentResponse = import_zod2.z.union([$stepResponse2, $orderResponse]);
-var MoonPayIntentResponseSchema = $intentResponse;
+var MoonPayResponseSchemaFor = {
+  observe: MoonPayStepResponseSchema,
+  consent: MoonPayStepResponseSchema,
+  connect: MoonPayStepResponseSchema,
+  kyc: MoonPayStepResponseSchema,
+  order: MoonPayOrderResponseSchema
+};
 var $faultFields = {
   reason: import_zod2.z.enum(["SESSION_BUDGET_SPENT", "RATE_LIMITED", "PROVIDER_UNAVAILABLE", "INVALID_REQUEST"]),
   recovery: import_zod2.z.enum(["RETRY", "REQUOTE", "NONE"])