@proxy-checkout/server-js 0.1.0-prx-146.161.1 → 0.1.0

package/dist/esm/live-contract-diagnostics.js

@@ -1,553 +0,0 @@
-import { requireBoolean, requireInteger, requireJsonObject, requireNullableString, requireString, } from "./response-validators.js";
-const maxSessions = 100;
-const maxRows = 2_000;
-const runIdPattern = /^stripe-contract-[a-z0-9-]{6,120}$/;
-export const proxyCheckoutLiveContractDiagnosticEndpoints = [
-    {
-        method: "GET",
-        operation: "liveContractDiagnostics.retrieve",
-        path: "/stripe_live_contract_diagnostics",
-    },
-];
-export class ProxyLiveContractDiagnosticsResource {
-    httpClient;
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-    }
-    async retrieve(input, options = {}) {
-        matchingString(input.runId, "liveContractDiagnostics.retrieve.runId", runIdPattern);
-        const query = new URLSearchParams();
-        query.set("run_id", input.runId);
-        query.set("merchant_psp_config_id", input.merchantPspConfigId);
-        const response = await this.httpClient.request("GET", `/stripe_live_contract_diagnostics?${query.toString()}`, undefined, options);
-        return parseDiagnostic(response);
-    }
-}
-function parseDiagnostic(response) {
-    const operation = "liveContractDiagnostics.retrieve";
-    const body = exactObject(response, operation, [
-        "baseline",
-        "config",
-        "deployment",
-        "run",
-        "version",
-    ]);
-    const baseline = exactObject(body.baseline, `${operation}.baseline`, [
-        "active_lifecycle_recovery_work",
-        "earned_fee_rows",
-        "non_none_fee_diagnostic_rows",
-        "open_acquisitions",
-        "undelivered_outbox_events",
-        "unresolved_reconciliation_issues",
-    ]);
-    const config = exactObject(body.config, `${operation}.config`, [
-        "account_ref_hash",
-        "id",
-        "ingress",
-        "lifecycle_status",
-        "merchant_mode",
-        "unattributed_open_acquisition_signal",
-    ]);
-    const deployment = exactObject(body.deployment, `${operation}.deployment`, [
-        "artifact_digest",
-        "commit_sha",
-        "environment",
-        "preview_id",
-    ]);
-    const run = exactObject(body.run, `${operation}.run`, ["id", "session_count", "sessions"]);
-    const sessions = boundedArray(run.sessions, `${operation}.run.sessions`, maxSessions).map((value, index) => parseSession(value, `${operation}.run.sessions[${index}]`));
-    const sessionCount = nonnegativeInteger(run.session_count, `${operation}.run.sessionCount`);
-    if (sessionCount !== sessions.length) {
-        throw new Error(`Proxy API response field ${operation}.run.sessionCount must match sessions.`);
-    }
-    const version = requireInteger(body.version, `${operation}.version`);
-    if (version !== 1) {
-        throw new Error(`Proxy API response field ${operation}.version must be 1.`);
-    }
-    const merchantMode = requireString(config.merchant_mode, `${operation}.config.merchantMode`);
-    if (merchantMode !== "test") {
-        throw new Error(`Proxy API response field ${operation}.config.merchantMode must be test.`);
-    }
-    const deploymentEnvironment = environment(deployment.environment, `${operation}.deployment.environment`);
-    const artifactDigest = optionalMatchingString(deployment.artifact_digest, `${operation}.deployment.artifactDigest`, /^[0-9a-f]{64}$/);
-    if (artifactDigest === null &&
-        (deploymentEnvironment === "preview" || deploymentEnvironment === "production")) {
-        throw new Error(`Proxy API response field ${operation}.deployment.artifactDigest is required for deployed environments.`);
-    }
-    return {
-        baseline: {
-            activeLifecycleRecoveryWork: nonnegativeInteger(baseline.active_lifecycle_recovery_work, `${operation}.baseline.activeLifecycleRecoveryWork`),
-            earnedFeeRows: nonnegativeInteger(baseline.earned_fee_rows, `${operation}.baseline.earnedFeeRows`),
-            nonNoneFeeDiagnosticRows: nonnegativeInteger(baseline.non_none_fee_diagnostic_rows, `${operation}.baseline.nonNoneFeeDiagnosticRows`),
-            openAcquisitions: nonnegativeInteger(baseline.open_acquisitions, `${operation}.baseline.openAcquisitions`),
-            undeliveredOutboxEvents: nonnegativeInteger(baseline.undelivered_outbox_events, `${operation}.baseline.undeliveredOutboxEvents`),
-            unresolvedReconciliationIssues: nonnegativeInteger(baseline.unresolved_reconciliation_issues, `${operation}.baseline.unresolvedReconciliationIssues`),
-        },
-        config: {
-            accountRefHash: optionalHash(config.account_ref_hash, `${operation}.config.accountRefHash`),
-            id: proxyId(config.id, `${operation}.config.id`, "pspcfg_"),
-            ingress: config.ingress === null
-                ? null
-                : parseIngress(config.ingress, `${operation}.config.ingress`),
-            lifecycleStatus: requireString(config.lifecycle_status, `${operation}.config.lifecycleStatus`),
-            merchantMode,
-            unattributedOpenAcquisitionSignal: requireBoolean(config.unattributed_open_acquisition_signal, `${operation}.config.unattributedOpenAcquisitionSignal`),
-        },
-        deployment: {
-            artifactDigest,
-            commitSha: matchingString(deployment.commit_sha, `${operation}.deployment.commitSha`, /^[0-9a-f]{40}$/),
-            environment: deploymentEnvironment,
-            previewId: requireNullableString(deployment.preview_id, `${operation}.deployment.previewId`),
-        },
-        run: {
-            id: matchingString(run.id, `${operation}.run.id`, runIdPattern),
-            sessionCount,
-            sessions,
-        },
-        version,
-    };
-}
-function parseSession(value, field) {
-    const body = exactObject(value, field, [
-        "acquisitions",
-        "completed_acquisition_attempt_id",
-        "completion_winner_count",
-        "domain_events",
-        "fees",
-        "final_cart",
-        "id",
-        "invoices",
-        "reconciliation_issues",
-        "recovery",
-        "shadow_comparisons",
-        "status",
-        "subscriptions",
-    ]);
-    return {
-        acquisitions: boundedArray(body.acquisitions, `${field}.acquisitions`, maxRows).map((item, index) => parseAcquisition(item, `${field}.acquisitions[${index}]`)),
-        completedAcquisitionAttemptId: optionalProxyId(body.completed_acquisition_attempt_id, `${field}.completedAcquisitionAttemptId`, "pspacq_"),
-        completionWinnerCount: nonnegativeInteger(body.completion_winner_count, `${field}.completionWinnerCount`),
-        domainEvents: boundedArray(body.domain_events, `${field}.domainEvents`, maxRows).map((item, index) => parseDomainEvent(item, `${field}.domainEvents[${index}]`)),
-        fees: boundedArray(body.fees, `${field}.fees`, maxRows).map((item, index) => parseFee(item, `${field}.fees[${index}]`)),
-        finalCart: body.final_cart === null ? null : parseFinalCart(body.final_cart, `${field}.finalCart`),
-        id: proxyId(body.id, `${field}.id`, "psess_"),
-        invoices: boundedArray(body.invoices, `${field}.invoices`, maxRows).map((item, index) => parseInvoice(item, `${field}.invoices[${index}]`)),
-        reconciliationIssues: boundedArray(body.reconciliation_issues, `${field}.reconciliationIssues`, maxRows).map((item, index) => parseReconciliationIssue(item, `${field}.reconciliationIssues[${index}]`)),
-        recovery: boundedArray(body.recovery, `${field}.recovery`, maxRows).map((item, index) => parseRecovery(item, `${field}.recovery[${index}]`)),
-        shadowComparisons: boundedArray(body.shadow_comparisons, `${field}.shadowComparisons`, maxRows).map((item, index) => parseShadowComparison(item, `${field}.shadowComparisons[${index}]`)),
-        status: requireString(body.status, `${field}.status`),
-        subscriptions: boundedArray(body.subscriptions, `${field}.subscriptions`, maxRows).map((item, index) => parseSubscription(item, `${field}.subscriptions[${index}]`)),
-    };
-}
-function parseAcquisition(value, field) {
-    const body = exactObject(value, field, [
-        "attempt_number",
-        "commercial_mode",
-        "completion_recorded",
-        "customer_present",
-        "direct_subscription_source",
-        "id",
-        "integration_path",
-        "pricing_mode",
-        "provider_cart_confirmed",
-        "root_object_present",
-        "setup_intent_present",
-        "setup_intent_evidence_source_type",
-        "status",
-        "status_reason",
-    ]);
-    return {
-        attemptNumber: positiveInteger(body.attempt_number, `${field}.attemptNumber`),
-        commercialMode: requireString(body.commercial_mode, `${field}.commercialMode`),
-        completionRecorded: requireBoolean(body.completion_recorded, `${field}.completionRecorded`),
-        customerPresent: requireBoolean(body.customer_present, `${field}.customerPresent`),
-        directSubscriptionSource: requireNullableString(body.direct_subscription_source, `${field}.directSubscriptionSource`),
-        id: proxyId(body.id, `${field}.id`, "pspacq_"),
-        integrationPath: requireString(body.integration_path, `${field}.integrationPath`),
-        pricingMode: requireString(body.pricing_mode, `${field}.pricingMode`),
-        providerCartConfirmed: requireBoolean(body.provider_cart_confirmed, `${field}.providerCartConfirmed`),
-        rootObjectPresent: requireBoolean(body.root_object_present, `${field}.rootObjectPresent`),
-        setupIntentEvidenceSourceType: evidenceSourceType(body.setup_intent_evidence_source_type, `${field}.setupIntentEvidenceSourceType`),
-        setupIntentPresent: requireBoolean(body.setup_intent_present, `${field}.setupIntentPresent`),
-        status: requireString(body.status, `${field}.status`),
-        statusReason: requireNullableString(body.status_reason, `${field}.statusReason`),
-    };
-}
-function parseSubscription(value, field) {
-    const body = exactObject(value, field, [
-        "configuration_reason",
-        "configuration_status",
-        "id",
-        "latest_payment_status",
-        "latest_payment_evidence_source_type",
-        "latest_proxy_invoice_id",
-        "lifecycle_evidence_source_type",
-        "status",
-    ]);
-    return {
-        configurationReason: requireNullableString(body.configuration_reason, `${field}.configurationReason`),
-        configurationStatus: requireString(body.configuration_status, `${field}.configurationStatus`),
-        id: proxyId(body.id, `${field}.id`, "psub_"),
-        latestPaymentEvidenceSourceType: evidenceSourceType(body.latest_payment_evidence_source_type, `${field}.latestPaymentEvidenceSourceType`),
-        latestPaymentStatus: requireNullableString(body.latest_payment_status, `${field}.latestPaymentStatus`),
-        latestProxyInvoiceId: optionalProxyId(body.latest_proxy_invoice_id, `${field}.latestProxyInvoiceId`, "pspsi_"),
-        lifecycleEvidenceSourceType: evidenceSourceType(body.lifecycle_evidence_source_type, `${field}.lifecycleEvidenceSourceType`),
-        status: requireString(body.status, `${field}.status`),
-    };
-}
-function parseInvoice(value, field) {
-    const body = exactObject(value, field, [
-        "amount_due_minor",
-        "amount_paid_minor",
-        "amount_remaining_minor",
-        "currency",
-        "dispute_observation_count",
-        "earned_fee_count",
-        "id",
-        "linked_payment_intent_fee_count",
-        "payment_attempt_count",
-        "provider_payment_intent_present",
-        "status_evidence_source_type",
-        "proxy_subscription_id",
-        "refund_observation_count",
-        "status",
-    ]);
-    return {
-        amountDueMinor: nonnegativeInteger(body.amount_due_minor, `${field}.amountDueMinor`),
-        amountPaidMinor: nonnegativeInteger(body.amount_paid_minor, `${field}.amountPaidMinor`),
-        amountRemainingMinor: nonnegativeInteger(body.amount_remaining_minor, `${field}.amountRemainingMinor`),
-        currency: optionalCurrency(body.currency, `${field}.currency`),
-        disputeObservationCount: nonnegativeInteger(body.dispute_observation_count, `${field}.disputeObservationCount`),
-        earnedFeeCount: nonnegativeInteger(body.earned_fee_count, `${field}.earnedFeeCount`),
-        id: proxyId(body.id, `${field}.id`, "pspsi_"),
-        linkedPaymentIntentFeeCount: nonnegativeInteger(body.linked_payment_intent_fee_count, `${field}.linkedPaymentIntentFeeCount`),
-        paymentAttemptCount: nonnegativeInteger(body.payment_attempt_count, `${field}.paymentAttemptCount`),
-        providerPaymentIntentPresent: requireBoolean(body.provider_payment_intent_present, `${field}.providerPaymentIntentPresent`),
-        proxySubscriptionId: proxyId(body.proxy_subscription_id, `${field}.proxySubscriptionId`, "psub_"),
-        refundObservationCount: nonnegativeInteger(body.refund_observation_count, `${field}.refundObservationCount`),
-        status: requireString(body.status, `${field}.status`),
-        statusEvidenceSourceType: evidenceSourceType(body.status_evidence_source_type, `${field}.statusEvidenceSourceType`),
-    };
-}
-function parseFee(value, field) {
-    const body = exactObject(value, field, [
-        "basis_diagnostic",
-        "billing_currency",
-        "earning_object_type",
-        "expected_fee_amount_decimal",
-        "fixed_fee_minor",
-        "id",
-        "payment_attempt_id",
-        "percentage_basis_amount_minor",
-        "percentage_basis_source",
-        "percentage_bps",
-        "policy_version",
-        "provider_acquisition_attempt_id",
-        "proxy_subscription_invoice_id",
-    ]);
-    const earningObjectType = requireString(body.earning_object_type, `${field}.earningObjectType`);
-    if (earningObjectType !== "invoice" && earningObjectType !== "payment_intent") {
-        throw new Error(`Proxy API response field ${field}.earningObjectType is unsupported.`);
-    }
-    return {
-        basisDiagnostic: requireString(body.basis_diagnostic, `${field}.basisDiagnostic`),
-        billingCurrency: currency(body.billing_currency, `${field}.billingCurrency`),
-        earningObjectType,
-        expectedFeeAmountDecimal: matchingString(body.expected_fee_amount_decimal, `${field}.expectedFeeAmountDecimal`, /^(0|[1-9][0-9]*)([.][0-9]+)?$/),
-        fixedFeeMinor: nonnegativeInteger(body.fixed_fee_minor, `${field}.fixedFeeMinor`),
-        id: proxyId(body.id, `${field}.id`, "strfee_"),
-        paymentAttemptId: proxyId(body.payment_attempt_id, `${field}.paymentAttemptId`, "payatt_"),
-        percentageBasisAmountMinor: nonnegativeInteger(body.percentage_basis_amount_minor, `${field}.percentageBasisAmountMinor`),
-        percentageBasisSource: requireString(body.percentage_basis_source, `${field}.percentageBasisSource`),
-        percentageBps: nonnegativeInteger(body.percentage_bps, `${field}.percentageBps`),
-        policyVersion: requireString(body.policy_version, `${field}.policyVersion`),
-        providerAcquisitionAttemptId: optionalProxyId(body.provider_acquisition_attempt_id, `${field}.providerAcquisitionAttemptId`, "pspacq_"),
-        proxySubscriptionInvoiceId: optionalProxyId(body.proxy_subscription_invoice_id, `${field}.proxySubscriptionInvoiceId`, "pspsi_"),
-    };
-}
-function parseDomainEvent(value, field) {
-    const body = exactObject(value, field, [
-        "id",
-        "outbox",
-        "payment_attempt_id",
-        "provider_acquisition_attempt_id",
-        "proxy_session_id",
-        "proxy_subscription_id",
-        "proxy_subscription_invoice_id",
-        "type",
-        "visibility",
-    ]);
-    return {
-        id: proxyId(body.id, `${field}.id`, "evt_"),
-        outbox: boundedArray(body.outbox, `${field}.outbox`, maxRows).map((item, index) => parseOutbox(item, `${field}.outbox[${index}]`)),
-        paymentAttemptId: optionalProxyId(body.payment_attempt_id, `${field}.paymentAttemptId`, "payatt_"),
-        providerAcquisitionAttemptId: optionalProxyId(body.provider_acquisition_attempt_id, `${field}.providerAcquisitionAttemptId`, "pspacq_"),
-        proxySessionId: optionalProxyId(body.proxy_session_id, `${field}.proxySessionId`, "psess_"),
-        proxySubscriptionId: optionalProxyId(body.proxy_subscription_id, `${field}.proxySubscriptionId`, "psub_"),
-        proxySubscriptionInvoiceId: optionalProxyId(body.proxy_subscription_invoice_id, `${field}.proxySubscriptionInvoiceId`, "pspsi_"),
-        type: requireString(body.type, `${field}.type`),
-        visibility: requireString(body.visibility, `${field}.visibility`),
-    };
-}
-function parseOutbox(value, field) {
-    const body = exactObject(value, field, [
-        "attempt_count",
-        "delivery",
-        "id",
-        "kind",
-        "max_attempts",
-        "status",
-    ]);
-    return {
-        attemptCount: nonnegativeInteger(body.attempt_count, `${field}.attemptCount`),
-        delivery: body.delivery === null ? null : parseDelivery(body.delivery, `${field}.delivery`),
-        id: proxyId(body.id, `${field}.id`, "out_"),
-        kind: requireString(body.kind, `${field}.kind`),
-        maxAttempts: positiveInteger(body.max_attempts, `${field}.maxAttempts`),
-        status: requireString(body.status, `${field}.status`),
-    };
-}
-function parseDelivery(value, field) {
-    const body = exactObject(value, field, ["attempt_count", "id", "status", "transport"]);
-    const transport = requireString(body.transport, `${field}.transport`);
-    if (transport !== "https" && transport !== "local_relay") {
-        throw new Error(`Proxy API response field ${field}.transport is unsupported.`);
-    }
-    return {
-        attemptCount: nonnegativeInteger(body.attempt_count, `${field}.attemptCount`),
-        id: proxyId(body.id, `${field}.id`, "whdel_"),
-        status: requireString(body.status, `${field}.status`),
-        transport,
-    };
-}
-function parseReconciliationIssue(value, field) {
-    const body = exactObject(value, field, [
-        "id",
-        "issue_type",
-        "payment_attempt_id",
-        "provider_acquisition_attempt_id",
-        "proxy_session_id",
-        "proxy_subscription_id",
-        "proxy_subscription_invoice_id",
-        "status",
-    ]);
-    return {
-        id: proxyId(body.id, `${field}.id`, "reciss_"),
-        issueType: requireString(body.issue_type, `${field}.issueType`),
-        paymentAttemptId: optionalProxyId(body.payment_attempt_id, `${field}.paymentAttemptId`, "payatt_"),
-        providerAcquisitionAttemptId: optionalProxyId(body.provider_acquisition_attempt_id, `${field}.providerAcquisitionAttemptId`, "pspacq_"),
-        proxySessionId: optionalProxyId(body.proxy_session_id, `${field}.proxySessionId`, "psess_"),
-        proxySubscriptionId: optionalProxyId(body.proxy_subscription_id, `${field}.proxySubscriptionId`, "psub_"),
-        proxySubscriptionInvoiceId: optionalProxyId(body.proxy_subscription_invoice_id, `${field}.proxySubscriptionInvoiceId`, "pspsi_"),
-        status: requireString(body.status, `${field}.status`),
-    };
-}
-function parseRecovery(value, field) {
-    const body = exactObject(value, field, [
-        "attempt_count",
-        "capability_ids",
-        "evidence_hash",
-        "evidence_present",
-        "id",
-        "max_attempts",
-        "provider_acquisition_attempt_id",
-        "proxy_session_id",
-        "proxy_subscription_id",
-        "proxy_subscription_invoice_id",
-        "result_disposition",
-        "result_reason",
-        "status",
-        "target_type",
-    ]);
-    return {
-        attemptCount: nonnegativeInteger(body.attempt_count, `${field}.attemptCount`),
-        capabilityIds: boundedArray(body.capability_ids, `${field}.capabilityIds`, 20).map((item, index) => requireString(item, `${field}.capabilityIds[${index}]`)),
-        evidenceHash: optionalMatchingString(body.evidence_hash, `${field}.evidenceHash`, /^sha256:[0-9a-f]{64}$/),
-        evidencePresent: requireBoolean(body.evidence_present, `${field}.evidencePresent`),
-        id: proxyId(body.id, `${field}.id`, "recwork_"),
-        maxAttempts: positiveInteger(body.max_attempts, `${field}.maxAttempts`),
-        providerAcquisitionAttemptId: proxyId(body.provider_acquisition_attempt_id, `${field}.providerAcquisitionAttemptId`, "pspacq_"),
-        proxySessionId: proxyId(body.proxy_session_id, `${field}.proxySessionId`, "psess_"),
-        proxySubscriptionId: optionalProxyId(body.proxy_subscription_id, `${field}.proxySubscriptionId`, "psub_"),
-        proxySubscriptionInvoiceId: optionalProxyId(body.proxy_subscription_invoice_id, `${field}.proxySubscriptionInvoiceId`, "pspsi_"),
-        resultDisposition: recoveryResultDisposition(body.result_disposition, `${field}.resultDisposition`),
-        resultReason: recoveryResultReason(body.result_reason, `${field}.resultReason`),
-        status: requireString(body.status, `${field}.status`),
-        targetType: requireString(body.target_type, `${field}.targetType`),
-    };
-}
-function parseShadowComparison(value, field) {
-    const body = exactObject(value, field, [
-        "comparison_hash",
-        "disposition",
-        "observation_count",
-        "reason_code",
-    ]);
-    return {
-        comparisonHash: matchingString(body.comparison_hash, `${field}.comparisonHash`, /^sha256:[0-9a-f]{64}$/),
-        disposition: shadowComparisonDisposition(body.disposition, `${field}.disposition`),
-        observationCount: positiveInteger(body.observation_count, `${field}.observationCount`),
-        reasonCode: shadowComparisonReasonCode(body.reason_code, `${field}.reasonCode`),
-    };
-}
-function parseFinalCart(value, field) {
-    const body = exactObject(value, field, [
-        "amount_minor",
-        "cart_version",
-        "currency",
-        "finalized_at",
-        "line_count",
-        "pricing_mode",
-        "snapshot_hash",
-    ]);
-    return {
-        amountMinor: nonnegativeInteger(body.amount_minor, `${field}.amountMinor`),
-        cartVersion: nonnegativeInteger(body.cart_version, `${field}.cartVersion`),
-        currency: currency(body.currency, `${field}.currency`),
-        finalizedAt: requireString(body.finalized_at, `${field}.finalizedAt`),
-        lineCount: nonnegativeInteger(body.line_count, `${field}.lineCount`),
-        pricingMode: requireString(body.pricing_mode, `${field}.pricingMode`),
-        snapshotHash: matchingString(body.snapshot_hash, `${field}.snapshotHash`, /^sha256:[0-9a-f]{64}$/),
-    };
-}
-function parseIngress(value, field) {
-    const body = exactObject(value, field, ["api_version", "verification_status"]);
-    return {
-        apiVersion: requireNullableString(body.api_version, `${field}.apiVersion`),
-        verificationStatus: requireString(body.verification_status, `${field}.verificationStatus`),
-    };
-}
-function exactObject(value, field, keys) {
-    const body = requireJsonObject(value, field);
-    const actual = Object.keys(body).sort();
-    const expected = [...keys].sort();
-    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
-        throw new Error(`Proxy API response field ${field} must contain only its documented keys.`);
-    }
-    return body;
-}
-function boundedArray(value, field, max) {
-    if (!Array.isArray(value) || value.length > max) {
-        throw new Error(`Proxy API response field ${field} must be an array of at most ${max} items.`);
-    }
-    return value;
-}
-function nonnegativeInteger(value, field) {
-    const parsed = requireInteger(value, field);
-    if (!Number.isSafeInteger(parsed) || parsed < 0) {
-        throw new Error(`Proxy API response field ${field} must be a nonnegative safe integer.`);
-    }
-    return parsed;
-}
-function positiveInteger(value, field) {
-    const parsed = nonnegativeInteger(value, field);
-    if (parsed < 1)
-        throw new Error(`Proxy API response field ${field} must be positive.`);
-    return parsed;
-}
-function matchingString(value, field, pattern) {
-    const parsed = requireString(value, field);
-    if (!pattern.test(parsed)) {
-        throw new Error(`Proxy API response field ${field} has an invalid format.`);
-    }
-    return parsed;
-}
-function optionalMatchingString(value, field, pattern) {
-    return value === null ? null : matchingString(value, field, pattern);
-}
-function proxyId(value, field, prefix) {
-    return matchingString(value, field, new RegExp(`^${prefix}[A-Za-z0-9._:-]+$`));
-}
-function optionalProxyId(value, field, prefix) {
-    return value === null ? null : proxyId(value, field, prefix);
-}
-function optionalHash(value, field) {
-    return value === null ? null : matchingString(value, field, /^sha256:[0-9a-f]{64}$/);
-}
-function evidenceSourceType(value, field) {
-    if (value === null)
-        return null;
-    const parsed = requireString(value, field);
-    if (parsed !== "psp_api_response" && parsed !== "webhook_event") {
-        throw new Error(`Proxy API response field ${field} is unsupported.`);
-    }
-    return parsed;
-}
-function recoveryResultDisposition(value, field) {
-    if (value === null)
-        return null;
-    const parsed = requireString(value, field);
-    if (parsed !== "action_required" &&
-        parsed !== "no_change" &&
-        parsed !== "resolved" &&
-        parsed !== "retry") {
-        throw new Error(`Proxy API response field ${field} is unsupported.`);
-    }
-    return parsed;
-}
-function recoveryResultReason(value, field) {
-    if (value === null)
-        return null;
-    const parsed = requireString(value, field);
-    const allowed = [
-        "completion_contender",
-        "incomplete_invoice_line_evidence",
-        "incomplete_invoice_structure",
-        "incomplete_subscription_configuration",
-        "invalid_or_unsupported_provider_evidence",
-        "known_object_not_found",
-        "stripe_credentials_unavailable",
-        "subscription_invoice_payment_evidence_conflict",
-        "unsupported_invoice_payment_evidence",
-        "unsupported_subscription_configuration",
-        "unclassified",
-    ];
-    if (!allowed.includes(parsed)) {
-        throw new Error(`Proxy API response field ${field} is unsupported.`);
-    }
-    return parsed;
-}
-function shadowComparisonDisposition(value, field) {
-    const parsed = requireString(value, field);
-    const allowed = [
-        "expected_divergence",
-        "legacy_not_applicable",
-        "match",
-        "unexpected_divergence",
-    ];
-    if (!allowed.includes(parsed)) {
-        throw new Error(`Proxy API response field ${field} is unsupported.`);
-    }
-    return parsed;
-}
-function shadowComparisonReasonCode(value, field) {
-    const parsed = requireString(value, field);
-    const allowed = [
-        "legacy_not_applicable",
-        "match",
-        "shared_configuration_visibility_added",
-        "shared_invoice_fee_and_lifecycle_added",
-        "shared_invoice_fee_added",
-        "shared_invoice_lifecycle_added",
-        "shared_invoice_line_evidence_required",
-        "shared_reconciliation_visibility_added",
-        "unexpected_divergence",
-    ];
-    if (!allowed.includes(parsed)) {
-        throw new Error(`Proxy API response field ${field} is unsupported.`);
-    }
-    return parsed;
-}
-function currency(value, field) {
-    return matchingString(value, field, /^[a-z]{3}$/);
-}
-function optionalCurrency(value, field) {
-    return value === null ? null : currency(value, field);
-}
-function environment(value, field) {
-    const parsed = requireString(value, field);
-    if (parsed !== "local" && parsed !== "preview" && parsed !== "production" && parsed !== "test") {
-        throw new Error(`Proxy API response field ${field} is unsupported.`);
-    }
-    return parsed;
-}