@alphawebai/hs-prism 0.1.0-rc.44 → 0.1.0-rc.46

package/dist/src/alphaweb/manifest.d.ts

@@ -1,7 +1,7 @@
 export declare const ALPHAWEB_STRIPE_WEBHOOK_EVENTS: readonly ["charge.dispute.closed", "charge.dispute.created", "charge.dispute.funds_reinstated", "charge.dispute.funds_withdrawn", "charge.dispute.updated", "mandate.updated", "payment_intent.amount_capturable_updated", "payment_intent.canceled", "payment_intent.payment_failed", "payment_intent.processing", "payment_intent.requires_action", "payment_intent.succeeded", "payment_method.attached", "payment_method.automatically_updated", "payment_method.detached", "payment_method.updated", "refund.created", "refund.failed", "refund.updated", "setup_intent.canceled", "setup_intent.requires_action", "setup_intent.setup_failed", "setup_intent.succeeded"];
 export declare const ALPHAWEB_PAYPAL_WEBHOOK_EVENTS: readonly ["CHECKOUT.ORDER.APPROVED", "CHECKOUT.ORDER.COMPLETED", "CHECKOUT.ORDER.PROCESSED", "CHECKOUT.PAYMENT-APPROVAL.REVERSED", "CUSTOMER.DISPUTE.CREATED", "CUSTOMER.DISPUTE.RESOLVED", "CUSTOMER.DISPUTE.UPDATED", "PAYMENT.AUTHORIZATION.CREATED", "PAYMENT.AUTHORIZATION.VOIDED", "PAYMENT.CAPTURE.COMPLETED", "PAYMENT.CAPTURE.DECLINED", "PAYMENT.CAPTURE.PENDING", "PAYMENT.CAPTURE.REFUNDED", "PAYMENT.CAPTURE.REVERSED", "PAYMENT.REFUND.FAILED", "PAYMENT.REFUND.PENDING", "RISK.DISPUTE.CREATED", "VAULT.PAYMENT-TOKEN.CREATED", "VAULT.PAYMENT-TOKEN.DELETED", "VAULT.PAYMENT-TOKEN.DELETION-INITIATED"];
 export declare const ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST: Readonly<{
-    readonly release: "0.1.0-rc.44";
+    readonly release: "0.1.0-rc.46";
     readonly upstreamCommit: "b07af7d9dac271de729548e74217ddcf895c602b";
     readonly medusaRange: ">=2.17.2 <2.18.0";
     readonly stripeApiVersion: "2026-06-24.dahlia";

package/dist/src/alphaweb/manifest.js

@@ -49,7 +49,7 @@ exports.ALPHAWEB_PAYPAL_WEBHOOK_EVENTS = Object.freeze([
     'VAULT.PAYMENT-TOKEN.DELETION-INITIATED',
 ]);
 exports.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST = Object.freeze({
-    release: '0.1.0-rc.44',
+    release: '0.1.0-rc.46',
     upstreamCommit: 'b07af7d9dac271de729548e74217ddcf895c602b',
     medusaRange: '>=2.17.2 <2.18.0',
     stripeApiVersion: '2026-06-24.dahlia',

package/dist/src/alphaweb/paypal-connector.js

@@ -134,9 +134,81 @@ function browserContinuation(input) {
     }
     return { returnUrl: returnUrl.toString(), cancelUrl: cancelUrl.toString() };
 }
+const PAYPAL_INTERVAL_MAXIMUM = {
+    day: 365,
+    week: 52,
+    month: 12,
+    year: 1,
+};
+function assertPayPalAgreementTerms(agreement) {
+    const planName = typeof agreement.planName === 'string' ? agreement.planName.trim() : '';
+    if (!planName || [...planName].length > 127) {
+        throw validationError('PayPal recurring plan name is invalid.', 'PRISM_PAYPAL_RECURRING_PLAN_NAME');
+    }
+    const maximumIntervalCount = Object.hasOwn(PAYPAL_INTERVAL_MAXIMUM, agreement.intervalUnit)
+        ? PAYPAL_INTERVAL_MAXIMUM[agreement.intervalUnit]
+        : undefined;
+    if (maximumIntervalCount === undefined ||
+        !Number.isSafeInteger(agreement.intervalCount) ||
+        agreement.intervalCount < 1 ||
+        agreement.intervalCount > maximumIntervalCount) {
+        throw validationError('PayPal recurring interval is outside the supported range.', 'PRISM_PAYPAL_RECURRING_INTERVAL');
+    }
+    if (agreement.totalPayments !== null &&
+        (!Number.isSafeInteger(agreement.totalPayments) ||
+            agreement.totalPayments < 2 ||
+            agreement.totalPayments > 999)) {
+        throw validationError('PayPal finite recurring agreements require between 2 and 999 total payments.', 'PRISM_PAYPAL_RECURRING_TOTAL');
+    }
+    return planName;
+}
+/**
+ * Independent plans never reach PayPal as a billing plan (Orders v2 accepts one
+ * billing_plan item), so PayPal's billing-plan cadence limits do not apply to
+ * them. They are validated for shape here so the vault-only order still carries
+ * the recurring usage pattern that matches the merchant's disclosure.
+ */
+function assertIndependentAgreements(agreements, money) {
+    const transactionMoney = (0, money_1.assertSafeProviderMoney)(money);
+    if (!Array.isArray(agreements) || agreements.length === 0) {
+        throw validationError('Independent recurring agreements cannot be empty.', 'PRISM_PAYPAL_RECURRING_AGREEMENT');
+    }
+    const keys = new Set();
+    for (const agreement of agreements) {
+        const planKey = typeof agreement.planKey === 'string' ? agreement.planKey.trim() : '';
+        if (!planKey || keys.has(planKey)) {
+            throw validationError('Independent recurring agreements need unique plan keys.', 'PRISM_PAYPAL_RECURRING_AGREEMENT');
+        }
+        keys.add(planKey);
+        if (!Number.isSafeInteger(agreement.quantity) || agreement.quantity < 1) {
+            throw validationError('Independent recurring agreement quantity is invalid.', 'PRISM_PAYPAL_RECURRING_AGREEMENT');
+        }
+        const planName = typeof agreement.planName === 'string' ? agreement.planName.trim() : '';
+        if (!planName) {
+            throw validationError('PayPal recurring plan name is invalid.', 'PRISM_PAYPAL_RECURRING_PLAN_NAME');
+        }
+        if (!Object.hasOwn(PAYPAL_INTERVAL_MAXIMUM, agreement.intervalUnit) ||
+            !Number.isSafeInteger(agreement.intervalCount) ||
+            agreement.intervalCount < 1) {
+            throw validationError('PayPal recurring interval is invalid.', 'PRISM_PAYPAL_RECURRING_INTERVAL');
+        }
+        if (agreement.totalPayments !== null &&
+            (!Number.isSafeInteger(agreement.totalPayments) || agreement.totalPayments < 1)) {
+            throw validationError('PayPal finite recurring agreements require a positive total payment count.', 'PRISM_PAYPAL_RECURRING_TOTAL');
+        }
+        const recurringMoney = (0, money_1.assertSafeProviderMoney)(agreement.recurringMoney);
+        if (recurringMoney.currency !== transactionMoney.currency) {
+            throw validationError('PayPal recurring money must use the checkout currency.', 'PRISM_PAYPAL_RECURRING_MONEY');
+        }
+    }
+}
 function futureUseMitCategoryFromIntent(futureUse) {
-    if (futureUse?.recurringAgreements) {
-        throw validationError('PayPal requires its supported single recurring agreement.', 'PRISM_INDEPENDENT_RECURRING_AGREEMENTS_UNSUPPORTED');
+    const independent = futureUse?.recurringAgreements;
+    if (independent) {
+        return independent.length > 0 &&
+            independent.every((agreement) => agreement.totalPayments !== null)
+            ? proto_1.types.MitCategory.INSTALLMENT_MIT
+            : proto_1.types.MitCategory.RECURRING_MIT;
     }
     if (futureUse?.recurringAgreement?.totalPayments !== null &&
         futureUse?.recurringAgreement?.totalPayments !== undefined) {
@@ -162,6 +234,17 @@ function repeatPaymentMitCategory(input) {
 function recurringAgreementMessage(input) {
     const wantsSubscription = input.futureUse?.purposes.includes('subscription') ?? false;
     const agreement = input.futureUse?.recurringAgreement;
+    const independent = input.futureUse?.recurringAgreements;
+    if (independent) {
+        if (agreement) {
+            throw validationError('Supply either the single PayPal agreement or independent agreements, not both.', 'PRISM_PAYPAL_RECURRING_AGREEMENT');
+        }
+        if (!wantsSubscription) {
+            throw validationError('Independent recurring agreements require subscription future use.', 'PRISM_PAYPAL_RECURRING_AGREEMENT');
+        }
+        assertIndependentAgreements(independent, input.money);
+        return undefined;
+    }
     if (!wantsSubscription && agreement) {
         throw validationError('A recurring agreement requires subscription future use.', 'PRISM_PAYPAL_RECURRING_AGREEMENT');
     }
@@ -172,43 +255,63 @@ function recurringAgreementMessage(input) {
         return undefined;
     const transactionMoney = (0, money_1.assertSafeProviderMoney)(input.money);
     const recurringMoney = (0, money_1.assertSafeProviderMoney)(agreement.recurringMoney);
-    if (transactionMoney.amountMinor !== recurringMoney.amountMinor ||
-        transactionMoney.currency !== recurringMoney.currency) {
+    if (transactionMoney.currency !== recurringMoney.currency ||
+        (!agreement.initialPayment && transactionMoney.amountMinor !== recurringMoney.amountMinor)) {
         throw validationError('PayPal recurring money must match the first checkout payment.', 'PRISM_PAYPAL_RECURRING_MONEY');
     }
-    const planName = agreement.planName.trim();
-    if (!planName || [...planName].length > 127) {
-        throw validationError('PayPal recurring plan name is invalid.', 'PRISM_PAYPAL_RECURRING_PLAN_NAME');
-    }
-    const maximumIntervalCount = {
-        day: 365,
-        week: 52,
-        month: 12,
-        year: 1,
-    }[agreement.intervalUnit];
-    if (!Number.isSafeInteger(agreement.intervalCount) ||
-        agreement.intervalCount < 1 ||
-        agreement.intervalCount > maximumIntervalCount) {
-        throw validationError('PayPal recurring interval is outside the supported range.', 'PRISM_PAYPAL_RECURRING_INTERVAL');
-    }
-    if (agreement.totalPayments !== null &&
-        (!Number.isSafeInteger(agreement.totalPayments) ||
-            agreement.totalPayments < 2 ||
-            agreement.totalPayments > 999)) {
-        throw validationError('PayPal finite recurring agreements require between 2 and 999 total payments.', 'PRISM_PAYPAL_RECURRING_TOTAL');
-    }
+    const planName = assertPayPalAgreementTerms(agreement);
     const intervalUnit = {
         day: proto_1.types.RecurringPaymentIntervalUnit.DAY,
         week: proto_1.types.RecurringPaymentIntervalUnit.WEEK,
         month: proto_1.types.RecurringPaymentIntervalUnit.MONTH,
         year: proto_1.types.RecurringPaymentIntervalUnit.YEAR,
     }[agreement.intervalUnit];
+    const initial = agreement.initialPayment;
+    let initialPayment;
+    if (initial) {
+        const minor = (value) => {
+            if (typeof value !== 'string' || !/^(0|[1-9][0-9]*)$/.test(value) || BigInt(value) > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw validationError('PayPal initial payment amounts are invalid.', 'PRISM_PAYPAL_RECURRING_MONEY');
+            }
+            return BigInt(value);
+        };
+        const plan = minor(initial.amountMinor);
+        const shipping = minor(initial.shippingAmountMinor);
+        const tax = minor(initial.taxAmountMinor);
+        const products = initial.oneTimeProducts ?? [];
+        let productTotal = 0n;
+        const oneTimeProducts = [];
+        if (!Array.isArray(products)) {
+            throw validationError('PayPal initial payment products are invalid.', 'PRISM_PAYPAL_RECURRING_MONEY');
+        }
+        for (const product of products) {
+            const name = typeof product?.name === 'string' ? product.name.trim() : '';
+            const amount = minor(product?.amountMinor);
+            if (!name || [...name].length > 127 || amount <= 0n || typeof product.requiresShipping !== 'boolean') {
+                throw validationError('PayPal initial payment products are invalid.', 'PRISM_PAYPAL_RECURRING_MONEY');
+            }
+            productTotal += amount;
+            oneTimeProducts.push({ name, amountMinor: Number(amount), requiresShipping: product.requiresShipping });
+        }
+        if (plan + shipping + tax + productTotal !== BigInt(input.money.amountMinor) ||
+            !/^\d{4}-\d{2}-\d{2}$/.test(initial.nextBillingDate) ||
+            !Number.isFinite(Date.parse(initial.nextBillingDate)) ||
+            new Date(initial.nextBillingDate).toISOString().slice(0, 10) !== initial.nextBillingDate) {
+            throw validationError('PayPal initial payment allocation is invalid.', 'PRISM_PAYPAL_RECURRING_MONEY');
+        }
+        initialPayment = {
+            amountMinor: Number(plan), shippingAmountMinor: Number(shipping), taxAmountMinor: Number(tax),
+            oneTimeProducts,
+            nextBillingDate: initial.nextBillingDate,
+        };
+    }
     return {
         planName,
         recurringAmount: moneyMessage(agreement.recurringMoney),
         intervalUnit,
         intervalCount: agreement.intervalCount,
         ...(agreement.totalPayments === null ? {} : { totalPayments: agreement.totalPayments }),
+        ...(initialPayment ? { initialPayment } : {}),
     };
 }
 function paymentStatus(status) {

package/dist/src/alphaweb/stripe-connector.d.ts

@@ -30,6 +30,7 @@ export declare class PrismStripeConnector implements PrismStripeConnectorV1 {
     private assertOperation;
     private recoverRepeatPayment;
     private stripeRequest;
+    private checkoutPaymentMethodSelection;
     createPayment(input: PrismMerchantOperation): Promise<PrismPaymentResult>;
     repeatPayment(input: PrismMerchantOperation): Promise<PrismPaymentResult>;
     retryPayment(input: PrismRetryPaymentInput): Promise<PrismPaymentResult>;

package/dist/src/alphaweb/stripe-connector.js

@@ -167,9 +167,8 @@ function buildResult(response, money, fallbackConnectorPaymentId = null) {
  * Package-owned intersection of Stripe's API support contract and the payment
  * method types represented by Prism's recurring-payment ABI.
  *
- * An interactive PaymentIntent can still use any method Stripe exposes through
- * automatic payment methods. This table only governs server-side reuse after
- * Stripe has attached the method to the proven Customer.
+ * One-time interactive payments retain Stripe's dynamic methods. Future-use
+ * checkout and server-side reuse share this capability authority.
  */
 const STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES = Object.freeze({
     amazon_pay: {
@@ -191,6 +190,7 @@ const STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES = Object.freeze({
         prismPaymentMethodType: proto_1.types.PaymentMethodType.IDEAL,
         supportsFutureUsage: true,
         supportsManualCapture: false,
+        requiresGeneratedDebit: true,
     },
     link: {
         prismPaymentMethodType: proto_1.types.PaymentMethodType.CREDIT,
@@ -207,6 +207,11 @@ const STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES = Object.freeze({
         supportsFutureUsage: true,
         supportsManualCapture: true,
     },
+    satispay: {
+        prismPaymentMethodType: proto_1.types.PaymentMethodType.SATISPAY,
+        supportsFutureUsage: true,
+        supportsManualCapture: true,
+    },
     sepa_debit: {
         prismPaymentMethodType: proto_1.types.PaymentMethodType.SEPA,
         supportsFutureUsage: true,
@@ -223,13 +228,20 @@ const STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES = Object.freeze({
         supportsManualCapture: false,
     },
 });
-function reusablePaymentMethodProfile(type) {
+function reusablePaymentMethodProfile(type, manualCapture = false) {
     const profile = STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES[type];
     if (!profile?.supportsFutureUsage) {
         throw configurationError('The saved Stripe payment method is not supported for a reusable Prism payment.', 'PRISM_REUSABLE_METHOD_UNSUPPORTED');
     }
+    if (manualCapture && !profile.supportsManualCapture) {
+        throw configurationError('The saved Stripe payment method does not support manual capture.', 'PRISM_REUSABLE_CAPTURE_UNSUPPORTED');
+    }
     return profile;
 }
+function supportsStripeFutureUse(profile, purposes) {
+    return profile.supportsFutureUsage &&
+        (!purposes.includes('post_purchase') || profile.supportsManualCapture);
+}
 const STRIPE_HARD_DECLINE_CODES = new Set([
     'authentication_required',
     'highest_risk_level',
@@ -749,6 +761,49 @@ class PrismStripeConnector {
             clearTimeout(timeout);
         }
     }
+    async checkoutPaymentMethodSelection(input) {
+        const purposes = input.futureUse?.purposes ??
+            (input.metadata.alphaweb_setup_future_usage === 'off_session' ? ['post_purchase'] : []);
+        if (purposes.length === 0)
+            return undefined;
+        const configurationId = input.methodSelection.kind === 'interactive_dynamic'
+            ? input.methodSelection.paymentMethodConfigurationId : undefined;
+        let configuration;
+        if (configurationId) {
+            configuration = recordOf(await this.stripeRequest('GET', `/payment_method_configurations/${encodeURIComponent(configurationId)}`));
+        }
+        else {
+            let after = null;
+            do {
+                const params = new URLSearchParams({ limit: '100', ...(after ? { starting_after: after } : {}) });
+                const page = recordOf(await this.stripeRequest('GET', `/payment_method_configurations?${params}`));
+                const configurations = Array.isArray(page.data) ? page.data.map(recordOf) : [];
+                configuration = configurations.find((entry) => entry.is_default === true);
+                if (configuration)
+                    break;
+                after = page.has_more === true ? stringOf(configurations.at(-1)?.id) : null;
+            } while (after);
+        }
+        const selectedId = stringOf(configuration?.id);
+        if (configuration?.active !== true || !selectedId) {
+            throw configurationError('Stripe payment method configuration is unavailable.', 'PRISM_METHOD_CONFIGURATION_UNAVAILABLE');
+        }
+        // Keep Stripe's configuration (including wallet controls). Translate our
+        // supported-flow table into native exclusions using Stripe's own method list.
+        const methods = Object.entries(configuration).filter(([, value]) => recordOf(value).display_preference);
+        const excludedPaymentMethodTypes = methods.filter(([type]) => {
+            // These configuration controls are card wallets/networks, not distinct PM types.
+            const method = ['apple_pay', 'google_pay', 'cartes_bancaires'].includes(type) ? 'card' : type;
+            const profile = STRIPE_REUSABLE_PAYMENT_METHOD_PROFILES[method];
+            return !profile || !supportsStripeFutureUse(profile, purposes) || profile.requiresGeneratedDebit ||
+                (input.metadata.alphaweb_capture_method === 'manual' && !profile.supportsManualCapture);
+        }).map(([type]) => type);
+        if (!methods.some(([type, value]) => !excludedPaymentMethodTypes.includes(type) &&
+            recordOf(value).available === true && recordOf(recordOf(value).display_preference).value === 'on')) {
+            throw configurationError('No enabled Stripe payment method supports this purchase and its future payments.', 'PRISM_PAYMENT_METHOD_FLOW_UNSUPPORTED');
+        }
+        return { paymentMethodConfigurationId: selectedId, excludedPaymentMethodTypes };
+    }
     async createPayment(input) {
         this.assertOperation(input);
         if (input.methodSelection.kind !== 'interactive_dynamic' || input.reusableReference) {
@@ -758,6 +813,7 @@ class PrismStripeConnector {
             throw configurationError('Interactive Stripe checkout requires a publishable key.', 'PRISM_PUBLISHABLE_KEY_REQUIRED');
         }
         try {
+            const methodSelection = await this.checkoutPaymentMethodSelection(input);
             const response = await this.dependencies.merchantAuthentication.createClientAuthenticationToken({
                 merchantClientSessionId: input.idempotencyKey,
                 testMode: this.options.environment === 'test',
@@ -771,7 +827,9 @@ class PrismStripeConnector {
                     captureMethod: input.metadata.alphaweb_capture_method === 'manual'
                         ? proto_1.types.CaptureMethod.MANUAL
                         : proto_1.types.CaptureMethod.AUTOMATIC,
-                    paymentMethodConfigurationId: input.methodSelection.paymentMethodConfigurationId,
+                    paymentMethodConfigurationId: methodSelection?.paymentMethodConfigurationId ??
+                        input.methodSelection.paymentMethodConfigurationId,
+                    excludedPaymentMethodTypes: methodSelection?.excludedPaymentMethodTypes,
                     merchantMetadata: operationMetadata(input),
                 },
             });
@@ -838,7 +896,7 @@ class PrismStripeConnector {
                     ? proto_1.types.CaptureMethod.MANUAL
                     : proto_1.types.CaptureMethod.AUTOMATIC,
                 connectorCustomerId: reference.connectorCustomerId,
-                paymentMethodType: reusablePaymentMethodProfile(paymentMethod.type).prismPaymentMethodType,
+                paymentMethodType: reusablePaymentMethodProfile(paymentMethod.type, input.metadata.alphaweb_capture_method === 'manual').prismPaymentMethodType,
                 offSession: true,
                 metadata: secret(JSON.stringify(operationMetadata(input))),
             });
@@ -892,7 +950,7 @@ class PrismStripeConnector {
             paymentMethod.livemode !== reference.livemode) {
             throw configurationError('Existing Stripe PaymentIntent is not eligible for this retry.', 'PRISM_RETRY_OWNERSHIP');
         }
-        reusablePaymentMethodProfile(paymentMethod.type);
+        reusablePaymentMethodProfile(paymentMethod.type, input.metadata.alphaweb_capture_method === 'manual');
         const body = new URLSearchParams({
             payment_method: reference.connectorPaymentMethodId,
             off_session: 'true',
@@ -989,7 +1047,7 @@ class PrismStripeConnector {
         }
         const requested = new Set(input.purposes);
         const capabilities = ['off_session'];
-        if (requested.has('post_purchase') && profile.supportsManualCapture) {
+        if (requested.has('post_purchase') && supportsStripeFutureUse(profile, ['post_purchase'])) {
             capabilities.push('post_purchase', 'manual_capture');
         }
         if (requested.has('subscription'))

package/dist/src/alphaweb/types.d.ts

@@ -21,11 +21,34 @@ export interface PrismRecurringAgreement {
     /** Total payments including the first checkout payment; null means until canceled. */
     totalPayments: number | null;
     recurringMoney: PrismMoney;
+    /** Initial checkout allocation; omitted for the existing equal-price single-plan flow. */
+    initialPayment?: {
+        /** This plan's initial item amount, excluding the separately disclosed shipping and tax. */
+        amountMinor: string;
+        shippingAmountMinor: string;
+        taxAmountMinor: string;
+        /**
+         * Every product or native bundle line paid today alongside the plan, each with
+         * its own net amount. Omit zero-priced lines; PayPal has no free-item representation.
+         */
+        oneTimeProducts?: Array<{
+            name: string;
+            amountMinor: string;
+            requiresShipping: boolean;
+        }>;
+        /** First regular renewal after an introductory period, as YYYY-MM-DD. */
+        nextBillingDate: string;
+    };
 }
 export interface PrismFutureUseIntent {
     purposes: [PrismFutureUsePurpose, ...PrismFutureUsePurpose[]];
     recurringAgreement?: PrismRecurringAgreement;
-    /** Independent merchant-managed Stripe plans. Mutually exclusive with the legacy single agreement. */
+    /**
+     * Independent merchant-managed plans, mutually exclusive with the legacy single
+     * agreement. Stripe saves the method for every plan. PayPal vaults the wallet for
+     * merchant-initiated renewals without a PayPal-side billing plan, because Orders v2
+     * carries at most one billing_plan item; the merchant checkout discloses each plan.
+     */
     recurringAgreements?: Array<PrismRecurringAgreement & {
         planKey: string;
         quantity: number;

package/dist/src/payments/generated/libconnector_service_ffi.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/src/payments/generated/libconnector_service_ffi.so
-size: 105603312 bytes
-sha256: 3a06d4ac03efca09613a3dab851ed68569b6d5b83e0f668a66fcbbcb76dcd54c
+size: 105630648 bytes
+sha256: 93607402e9d0d7ffa2a03ca3c6ca04573d10d767acc8dca694864c2f65280ffc

package/dist/src/payments/generated/proto.d.ts

@@ -12034,6 +12034,9 @@ export namespace types {
          * agreement continues until canceled.
          */
         totalPayments?: (number|null);
+
+        /** RecurringAgreement initialPayment */
+        initialPayment?: (types.IRecurringInitialPayment|null);
     }
 
     /**
@@ -12067,6 +12070,9 @@ export namespace types {
          */
         public totalPayments?: (number|null);
 
+        /** RecurringAgreement initialPayment. */
+        public initialPayment?: (types.IRecurringInitialPayment|null);
+
         /**
          * Creates a new RecurringAgreement instance using the specified properties.
          * @param [properties] Properties to set
@@ -12107,6 +12113,169 @@ export namespace types {
         public static getTypeUrl(typeUrlPrefix?: string): string;
     }
 
+    /** Properties of a RecurringInitialPayment. */
+    interface IRecurringInitialPayment {
+
+        /** RecurringInitialPayment amountMinor */
+        amountMinor?: (number|Long|null);
+
+        /** RecurringInitialPayment shippingAmountMinor */
+        shippingAmountMinor?: (number|Long|null);
+
+        /** RecurringInitialPayment taxAmountMinor */
+        taxAmountMinor?: (number|Long|null);
+
+        /**
+         * Every product or native bundle line paid today alongside the plan, each
+         * with its own net amount. Empty for a plan-only first payment.
+         */
+        oneTimeProducts?: (types.IRecurringInitialOneTimeProduct[]|null);
+
+        /** RecurringInitialPayment nextBillingDate */
+        nextBillingDate?: (string|null);
+    }
+
+    /**
+     * Initial checkout amounts use the agreement's currency. The recurring amount
+     * remains the disclosed future plan price, not the combined checkout total.
+     */
+    class RecurringInitialPayment implements IRecurringInitialPayment {
+
+        /**
+         * Constructs a new RecurringInitialPayment.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: types.IRecurringInitialPayment);
+
+        /** RecurringInitialPayment amountMinor. */
+        public amountMinor: (number|Long);
+
+        /** RecurringInitialPayment shippingAmountMinor. */
+        public shippingAmountMinor: (number|Long);
+
+        /** RecurringInitialPayment taxAmountMinor. */
+        public taxAmountMinor: (number|Long);
+
+        /**
+         * Every product or native bundle line paid today alongside the plan, each
+         * with its own net amount. Empty for a plan-only first payment.
+         */
+        public oneTimeProducts: types.IRecurringInitialOneTimeProduct[];
+
+        /** RecurringInitialPayment nextBillingDate. */
+        public nextBillingDate: string;
+
+        /**
+         * Creates a new RecurringInitialPayment instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns RecurringInitialPayment instance
+         */
+        public static create(properties?: types.IRecurringInitialPayment): types.RecurringInitialPayment;
+
+        /**
+         * Encodes the specified RecurringInitialPayment message. Does not implicitly {@link types.RecurringInitialPayment.verify|verify} messages.
+         * @param message RecurringInitialPayment message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: types.IRecurringInitialPayment, writer?: $protobuf.Writer): $protobuf.Writer;
+
+        /**
+         * Decodes a RecurringInitialPayment message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns RecurringInitialPayment
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): types.RecurringInitialPayment;
+
+        /**
+         * Verifies a RecurringInitialPayment message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Gets the default type url for RecurringInitialPayment
+         * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns The default type url
+         */
+        public static getTypeUrl(typeUrlPrefix?: string): string;
+    }
+
+    /** Properties of a RecurringInitialOneTimeProduct. */
+    interface IRecurringInitialOneTimeProduct {
+
+        /** RecurringInitialOneTimeProduct name */
+        name?: (string|null);
+
+        /** RecurringInitialOneTimeProduct amountMinor */
+        amountMinor?: (number|Long|null);
+
+        /** RecurringInitialOneTimeProduct requiresShipping */
+        requiresShipping?: (boolean|null);
+    }
+
+    /** Represents a RecurringInitialOneTimeProduct. */
+    class RecurringInitialOneTimeProduct implements IRecurringInitialOneTimeProduct {
+
+        /**
+         * Constructs a new RecurringInitialOneTimeProduct.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: types.IRecurringInitialOneTimeProduct);
+
+        /** RecurringInitialOneTimeProduct name. */
+        public name: string;
+
+        /** RecurringInitialOneTimeProduct amountMinor. */
+        public amountMinor: (number|Long);
+
+        /** RecurringInitialOneTimeProduct requiresShipping. */
+        public requiresShipping: boolean;
+
+        /**
+         * Creates a new RecurringInitialOneTimeProduct instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns RecurringInitialOneTimeProduct instance
+         */
+        public static create(properties?: types.IRecurringInitialOneTimeProduct): types.RecurringInitialOneTimeProduct;
+
+        /**
+         * Encodes the specified RecurringInitialOneTimeProduct message. Does not implicitly {@link types.RecurringInitialOneTimeProduct.verify|verify} messages.
+         * @param message RecurringInitialOneTimeProduct message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: types.IRecurringInitialOneTimeProduct, writer?: $protobuf.Writer): $protobuf.Writer;
+
+        /**
+         * Decodes a RecurringInitialOneTimeProduct message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns RecurringInitialOneTimeProduct
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): types.RecurringInitialOneTimeProduct;
+
+        /**
+         * Verifies a RecurringInitialOneTimeProduct message.
+         * @param message Plain object to verify
+         * @returns `null` if valid, otherwise the reason why it is not
+         */
+        public static verify(message: { [k: string]: any }): (string|null);
+
+        /**
+         * Gets the default type url for RecurringInitialOneTimeProduct
+         * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns The default type url
+         */
+        public static getTypeUrl(typeUrlPrefix?: string): string;
+    }
+
     /** Properties of a PaypalClientAuthenticationResponse. */
     interface IPaypalClientAuthenticationResponse {
 
@@ -14624,6 +14793,9 @@ export namespace types {
 
         /** PaymentClientAuthenticationContext merchantMetadata */
         merchantMetadata?: ({ [k: string]: string }|null);
+
+        /** Flow-specific exclusions; empty retains the connector's dynamic defaults. */
+        excludedPaymentMethodTypes?: (string[]|null);
     }
 
     /** Payment-specific context for client authentication token creation */
@@ -14674,6 +14846,9 @@ export namespace types {
         /** PaymentClientAuthenticationContext merchantMetadata. */
         public merchantMetadata: { [k: string]: string };
 
+        /** Flow-specific exclusions; empty retains the connector's dynamic defaults. */
+        public excludedPaymentMethodTypes: string[];
+
         /**
          * Creates a new PaymentClientAuthenticationContext instance using the specified properties.
          * @param [properties] Properties to set

package/dist/src/payments/generated/proto.js

@@ -36110,6 +36110,7 @@ $root.types = (function() {
          * @property {number|null} [intervalCount] RecurringAgreement intervalCount
          * @property {number|null} [totalPayments] Total payments includes the first checkout payment. Omitted means the
          * agreement continues until canceled.
+         * @property {types.IRecurringInitialPayment|null} [initialPayment] RecurringAgreement initialPayment
          */
 
         /**
@@ -36170,6 +36171,14 @@ $root.types = (function() {
          */
         RecurringAgreement.prototype.totalPayments = null;
 
+        /**
+         * RecurringAgreement initialPayment.
+         * @member {types.IRecurringInitialPayment|null|undefined} initialPayment
+         * @memberof types.RecurringAgreement
+         * @instance
+         */
+        RecurringAgreement.prototype.initialPayment = null;
+
         // OneOf field names bound to virtual getters and setters
         var $oneOfFields;
 
@@ -36179,6 +36188,12 @@ $root.types = (function() {
             set: $util.oneOfSetter($oneOfFields)
         });
 
+        // Virtual OneOf for proto3 optional field
+        Object.defineProperty(RecurringAgreement.prototype, "_initialPayment", {
+            get: $util.oneOfGetter($oneOfFields = ["initialPayment"]),
+            set: $util.oneOfSetter($oneOfFields)
+        });
+
         /**
          * Creates a new RecurringAgreement instance using the specified properties.
          * @function create
@@ -36217,6 +36232,8 @@ $root.types = (function() {
                 writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.intervalCount);
             if (message.totalPayments != null && Object.hasOwnProperty.call(message, "totalPayments"))
                 writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.totalPayments);
+            if (message.initialPayment != null && Object.hasOwnProperty.call(message, "initialPayment"))
+                $root.types.RecurringInitialPayment.encode(message.initialPayment, writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim();
             return writer;
         };
 
@@ -36264,6 +36281,10 @@ $root.types = (function() {
                         message.totalPayments = reader.uint32();
                         break;
                     }
+                case 6: {
+                        message.initialPayment = $root.types.RecurringInitialPayment.decode(reader, reader.uint32(), undefined, long + 1);
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -36317,6 +36338,14 @@ $root.types = (function() {
                 if (!$util.isInteger(message.totalPayments))
                     return "totalPayments: integer expected";
             }
+            if (message.initialPayment != null && Object.hasOwnProperty.call(message, "initialPayment")) {
+                properties._initialPayment = 1;
+                {
+                    var error = $root.types.RecurringInitialPayment.verify(message.initialPayment, long + 1);
+                    if (error)
+                        return "initialPayment." + error;
+                }
+            }
             return null;
         };
 
@@ -36338,6 +36367,407 @@ $root.types = (function() {
         return RecurringAgreement;
     })();
 
+    types.RecurringInitialPayment = (function() {
+
+        /**
+         * Properties of a RecurringInitialPayment.
+         * @memberof types
+         * @interface IRecurringInitialPayment
+         * @property {number|Long|null} [amountMinor] RecurringInitialPayment amountMinor
+         * @property {number|Long|null} [shippingAmountMinor] RecurringInitialPayment shippingAmountMinor
+         * @property {number|Long|null} [taxAmountMinor] RecurringInitialPayment taxAmountMinor
+         * @property {Array.<types.IRecurringInitialOneTimeProduct>|null} [oneTimeProducts] Every product or native bundle line paid today alongside the plan, each
+         * with its own net amount. Empty for a plan-only first payment.
+         * @property {string|null} [nextBillingDate] RecurringInitialPayment nextBillingDate
+         */
+
+        /**
+         * Constructs a new RecurringInitialPayment.
+         * @memberof types
+         * @classdesc Initial checkout amounts use the agreement's currency. The recurring amount
+         * remains the disclosed future plan price, not the combined checkout total.
+         * @implements IRecurringInitialPayment
+         * @constructor
+         * @param {types.IRecurringInitialPayment=} [properties] Properties to set
+         */
+        function RecurringInitialPayment(properties) {
+            this.oneTimeProducts = [];
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * RecurringInitialPayment amountMinor.
+         * @member {number|Long} amountMinor
+         * @memberof types.RecurringInitialPayment
+         * @instance
+         */
+        RecurringInitialPayment.prototype.amountMinor = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+
+        /**
+         * RecurringInitialPayment shippingAmountMinor.
+         * @member {number|Long} shippingAmountMinor
+         * @memberof types.RecurringInitialPayment
+         * @instance
+         */
+        RecurringInitialPayment.prototype.shippingAmountMinor = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+
+        /**
+         * RecurringInitialPayment taxAmountMinor.
+         * @member {number|Long} taxAmountMinor
+         * @memberof types.RecurringInitialPayment
+         * @instance
+         */
+        RecurringInitialPayment.prototype.taxAmountMinor = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+
+        /**
+         * Every product or native bundle line paid today alongside the plan, each
+         * with its own net amount. Empty for a plan-only first payment.
+         * @member {Array.<types.IRecurringInitialOneTimeProduct>} oneTimeProducts
+         * @memberof types.RecurringInitialPayment
+         * @instance
+         */
+        RecurringInitialPayment.prototype.oneTimeProducts = $util.emptyArray;
+
+        /**
+         * RecurringInitialPayment nextBillingDate.
+         * @member {string} nextBillingDate
+         * @memberof types.RecurringInitialPayment
+         * @instance
+         */
+        RecurringInitialPayment.prototype.nextBillingDate = "";
+
+        /**
+         * Creates a new RecurringInitialPayment instance using the specified properties.
+         * @function create
+         * @memberof types.RecurringInitialPayment
+         * @static
+         * @param {types.IRecurringInitialPayment=} [properties] Properties to set
+         * @returns {types.RecurringInitialPayment} RecurringInitialPayment instance
+         */
+        RecurringInitialPayment.create = function create(properties) {
+            return new RecurringInitialPayment(properties);
+        };
+
+        /**
+         * Encodes the specified RecurringInitialPayment message. Does not implicitly {@link types.RecurringInitialPayment.verify|verify} messages.
+         * @function encode
+         * @memberof types.RecurringInitialPayment
+         * @static
+         * @param {types.IRecurringInitialPayment} message RecurringInitialPayment message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        RecurringInitialPayment.encode = function encode(message, writer, q) {
+            if (!writer)
+                writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            if (message.amountMinor != null && Object.hasOwnProperty.call(message, "amountMinor"))
+                writer.uint32(/* id 1, wireType 0 =*/8).int64(message.amountMinor);
+            if (message.shippingAmountMinor != null && Object.hasOwnProperty.call(message, "shippingAmountMinor"))
+                writer.uint32(/* id 2, wireType 0 =*/16).int64(message.shippingAmountMinor);
+            if (message.taxAmountMinor != null && Object.hasOwnProperty.call(message, "taxAmountMinor"))
+                writer.uint32(/* id 3, wireType 0 =*/24).int64(message.taxAmountMinor);
+            if (message.oneTimeProducts != null && message.oneTimeProducts.length)
+                for (var i = 0; i < message.oneTimeProducts.length; ++i)
+                    $root.types.RecurringInitialOneTimeProduct.encode(message.oneTimeProducts[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim();
+            if (message.nextBillingDate != null && Object.hasOwnProperty.call(message, "nextBillingDate"))
+                writer.uint32(/* id 5, wireType 2 =*/42).string(message.nextBillingDate);
+            return writer;
+        };
+
+        /**
+         * Decodes a RecurringInitialPayment message from the specified reader or buffer.
+         * @function decode
+         * @memberof types.RecurringInitialPayment
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {types.RecurringInitialPayment} RecurringInitialPayment
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        RecurringInitialPayment.decode = function decode(reader, length, error, long) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.types.RecurringInitialPayment();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                if (tag === error)
+                    break;
+                switch (tag >>> 3) {
+                case 1: {
+                        message.amountMinor = reader.int64();
+                        break;
+                    }
+                case 2: {
+                        message.shippingAmountMinor = reader.int64();
+                        break;
+                    }
+                case 3: {
+                        message.taxAmountMinor = reader.int64();
+                        break;
+                    }
+                case 4: {
+                        if (!(message.oneTimeProducts && message.oneTimeProducts.length))
+                            message.oneTimeProducts = [];
+                        message.oneTimeProducts.push($root.types.RecurringInitialOneTimeProduct.decode(reader, reader.uint32(), undefined, long + 1));
+                        break;
+                    }
+                case 5: {
+                        message.nextBillingDate = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7, long);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Verifies a RecurringInitialPayment message.
+         * @function verify
+         * @memberof types.RecurringInitialPayment
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        RecurringInitialPayment.verify = function verify(message, long) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
+            if (message.amountMinor != null && Object.hasOwnProperty.call(message, "amountMinor"))
+                if (!$util.isInteger(message.amountMinor) && !(message.amountMinor && $util.isInteger(message.amountMinor.low) && $util.isInteger(message.amountMinor.high)))
+                    return "amountMinor: integer|Long expected";
+            if (message.shippingAmountMinor != null && Object.hasOwnProperty.call(message, "shippingAmountMinor"))
+                if (!$util.isInteger(message.shippingAmountMinor) && !(message.shippingAmountMinor && $util.isInteger(message.shippingAmountMinor.low) && $util.isInteger(message.shippingAmountMinor.high)))
+                    return "shippingAmountMinor: integer|Long expected";
+            if (message.taxAmountMinor != null && Object.hasOwnProperty.call(message, "taxAmountMinor"))
+                if (!$util.isInteger(message.taxAmountMinor) && !(message.taxAmountMinor && $util.isInteger(message.taxAmountMinor.low) && $util.isInteger(message.taxAmountMinor.high)))
+                    return "taxAmountMinor: integer|Long expected";
+            if (message.oneTimeProducts != null && Object.hasOwnProperty.call(message, "oneTimeProducts")) {
+                if (!Array.isArray(message.oneTimeProducts))
+                    return "oneTimeProducts: array expected";
+                for (var i = 0; i < message.oneTimeProducts.length; ++i) {
+                    var error = $root.types.RecurringInitialOneTimeProduct.verify(message.oneTimeProducts[i], long + 1);
+                    if (error)
+                        return "oneTimeProducts." + error;
+                }
+            }
+            if (message.nextBillingDate != null && Object.hasOwnProperty.call(message, "nextBillingDate"))
+                if (!$util.isString(message.nextBillingDate))
+                    return "nextBillingDate: string expected";
+            return null;
+        };
+
+        /**
+         * Gets the default type url for RecurringInitialPayment
+         * @function getTypeUrl
+         * @memberof types.RecurringInitialPayment
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        RecurringInitialPayment.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/types.RecurringInitialPayment";
+        };
+
+        return RecurringInitialPayment;
+    })();
+
+    types.RecurringInitialOneTimeProduct = (function() {
+
+        /**
+         * Properties of a RecurringInitialOneTimeProduct.
+         * @memberof types
+         * @interface IRecurringInitialOneTimeProduct
+         * @property {string|null} [name] RecurringInitialOneTimeProduct name
+         * @property {number|Long|null} [amountMinor] RecurringInitialOneTimeProduct amountMinor
+         * @property {boolean|null} [requiresShipping] RecurringInitialOneTimeProduct requiresShipping
+         */
+
+        /**
+         * Constructs a new RecurringInitialOneTimeProduct.
+         * @memberof types
+         * @classdesc Represents a RecurringInitialOneTimeProduct.
+         * @implements IRecurringInitialOneTimeProduct
+         * @constructor
+         * @param {types.IRecurringInitialOneTimeProduct=} [properties] Properties to set
+         */
+        function RecurringInitialOneTimeProduct(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * RecurringInitialOneTimeProduct name.
+         * @member {string} name
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @instance
+         */
+        RecurringInitialOneTimeProduct.prototype.name = "";
+
+        /**
+         * RecurringInitialOneTimeProduct amountMinor.
+         * @member {number|Long} amountMinor
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @instance
+         */
+        RecurringInitialOneTimeProduct.prototype.amountMinor = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+
+        /**
+         * RecurringInitialOneTimeProduct requiresShipping.
+         * @member {boolean} requiresShipping
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @instance
+         */
+        RecurringInitialOneTimeProduct.prototype.requiresShipping = false;
+
+        /**
+         * Creates a new RecurringInitialOneTimeProduct instance using the specified properties.
+         * @function create
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @static
+         * @param {types.IRecurringInitialOneTimeProduct=} [properties] Properties to set
+         * @returns {types.RecurringInitialOneTimeProduct} RecurringInitialOneTimeProduct instance
+         */
+        RecurringInitialOneTimeProduct.create = function create(properties) {
+            return new RecurringInitialOneTimeProduct(properties);
+        };
+
+        /**
+         * Encodes the specified RecurringInitialOneTimeProduct message. Does not implicitly {@link types.RecurringInitialOneTimeProduct.verify|verify} messages.
+         * @function encode
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @static
+         * @param {types.IRecurringInitialOneTimeProduct} message RecurringInitialOneTimeProduct message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        RecurringInitialOneTimeProduct.encode = function encode(message, writer, q) {
+            if (!writer)
+                writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
+            if (message.amountMinor != null && Object.hasOwnProperty.call(message, "amountMinor"))
+                writer.uint32(/* id 2, wireType 0 =*/16).int64(message.amountMinor);
+            if (message.requiresShipping != null && Object.hasOwnProperty.call(message, "requiresShipping"))
+                writer.uint32(/* id 3, wireType 0 =*/24).bool(message.requiresShipping);
+            return writer;
+        };
+
+        /**
+         * Decodes a RecurringInitialOneTimeProduct message from the specified reader or buffer.
+         * @function decode
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {types.RecurringInitialOneTimeProduct} RecurringInitialOneTimeProduct
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        RecurringInitialOneTimeProduct.decode = function decode(reader, length, error, long) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.types.RecurringInitialOneTimeProduct();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                if (tag === error)
+                    break;
+                switch (tag >>> 3) {
+                case 1: {
+                        message.name = reader.string();
+                        break;
+                    }
+                case 2: {
+                        message.amountMinor = reader.int64();
+                        break;
+                    }
+                case 3: {
+                        message.requiresShipping = reader.bool();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7, long);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Verifies a RecurringInitialOneTimeProduct message.
+         * @function verify
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        RecurringInitialOneTimeProduct.verify = function verify(message, long) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
+            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+                if (!$util.isString(message.name))
+                    return "name: string expected";
+            if (message.amountMinor != null && Object.hasOwnProperty.call(message, "amountMinor"))
+                if (!$util.isInteger(message.amountMinor) && !(message.amountMinor && $util.isInteger(message.amountMinor.low) && $util.isInteger(message.amountMinor.high)))
+                    return "amountMinor: integer|Long expected";
+            if (message.requiresShipping != null && Object.hasOwnProperty.call(message, "requiresShipping"))
+                if (typeof message.requiresShipping !== "boolean")
+                    return "requiresShipping: boolean expected";
+            return null;
+        };
+
+        /**
+         * Gets the default type url for RecurringInitialOneTimeProduct
+         * @function getTypeUrl
+         * @memberof types.RecurringInitialOneTimeProduct
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        RecurringInitialOneTimeProduct.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/types.RecurringInitialOneTimeProduct";
+        };
+
+        return RecurringInitialOneTimeProduct;
+    })();
+
     types.PaypalClientAuthenticationResponse = (function() {
 
         /**
@@ -45486,6 +45916,7 @@ $root.types = (function() {
          * @property {types.CaptureMethod|null} [captureMethod] PaymentClientAuthenticationContext captureMethod
          * @property {string|null} [paymentMethodConfigurationId] PaymentClientAuthenticationContext paymentMethodConfigurationId
          * @property {Object.<string,string>|null} [merchantMetadata] PaymentClientAuthenticationContext merchantMetadata
+         * @property {Array.<string>|null} [excludedPaymentMethodTypes] Flow-specific exclusions; empty retains the connector's dynamic defaults.
          */
 
         /**
@@ -45498,6 +45929,7 @@ $root.types = (function() {
          */
         function PaymentClientAuthenticationContext(properties) {
             this.merchantMetadata = {};
+            this.excludedPaymentMethodTypes = [];
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                     if (properties[keys[i]] != null && keys[i] !== "__proto__")
@@ -45608,6 +46040,14 @@ $root.types = (function() {
          */
         PaymentClientAuthenticationContext.prototype.merchantMetadata = $util.emptyObject;
 
+        /**
+         * Flow-specific exclusions; empty retains the connector's dynamic defaults.
+         * @member {Array.<string>} excludedPaymentMethodTypes
+         * @memberof types.PaymentClientAuthenticationContext
+         * @instance
+         */
+        PaymentClientAuthenticationContext.prototype.excludedPaymentMethodTypes = $util.emptyArray;
+
         // OneOf field names bound to virtual getters and setters
         var $oneOfFields;
 
@@ -45732,6 +46172,9 @@ $root.types = (function() {
             if (message.merchantMetadata != null && Object.hasOwnProperty.call(message, "merchantMetadata"))
                 for (var keys = Object.keys(message.merchantMetadata), i = 0; i < keys.length; ++i)
                     writer.uint32(/* id 13, wireType 2 =*/106).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.merchantMetadata[keys[i]]).ldelim();
+            if (message.excludedPaymentMethodTypes != null && message.excludedPaymentMethodTypes.length)
+                for (var i = 0; i < message.excludedPaymentMethodTypes.length; ++i)
+                    writer.uint32(/* id 14, wireType 2 =*/114).string(message.excludedPaymentMethodTypes[i]);
             return writer;
         };
 
@@ -45832,6 +46275,12 @@ $root.types = (function() {
                         message.merchantMetadata[key] = value;
                         break;
                     }
+                case 14: {
+                        if (!(message.excludedPaymentMethodTypes && message.excludedPaymentMethodTypes.length))
+                            message.excludedPaymentMethodTypes = [];
+                        message.excludedPaymentMethodTypes.push(reader.string());
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -46316,6 +46765,13 @@ $root.types = (function() {
                     if (!$util.isString(message.merchantMetadata[key[i]]))
                         return "merchantMetadata: string{k:string} expected";
             }
+            if (message.excludedPaymentMethodTypes != null && Object.hasOwnProperty.call(message, "excludedPaymentMethodTypes")) {
+                if (!Array.isArray(message.excludedPaymentMethodTypes))
+                    return "excludedPaymentMethodTypes: array expected";
+                for (var i = 0; i < message.excludedPaymentMethodTypes.length; ++i)
+                    if (!$util.isString(message.excludedPaymentMethodTypes[i]))
+                        return "excludedPaymentMethodTypes: string[] expected";
+            }
             return null;
         };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphawebai/hs-prism",
-  "version": "0.1.0-rc.44",
+  "version": "0.1.0-rc.46",
   "description": "Hyperswitch Payments SDK — Node.js client for connector integrations via UniFFI FFI",
   "main": "dist/src/index.js",
   "exports": {