@alphawebai/hs-prism 0.1.0-rc.27

package/dist/src/alphaweb/contracts.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toProviderMinorAmount = exports.getCurrencyRule = exports.fromProviderMinorAmount = exports.assertSafeProviderMoney = exports.normalizePrismError = exports.PrismOperationError = exports.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST = void 0;
+var manifest_1 = require("./manifest");
+Object.defineProperty(exports, "ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST", { enumerable: true, get: function () { return manifest_1.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "PrismOperationError", { enumerable: true, get: function () { return error_1.PrismOperationError; } });
+Object.defineProperty(exports, "normalizePrismError", { enumerable: true, get: function () { return error_1.normalizePrismError; } });
+var money_1 = require("./money");
+Object.defineProperty(exports, "assertSafeProviderMoney", { enumerable: true, get: function () { return money_1.assertSafeProviderMoney; } });
+Object.defineProperty(exports, "fromProviderMinorAmount", { enumerable: true, get: function () { return money_1.fromProviderMinorAmount; } });
+Object.defineProperty(exports, "getCurrencyRule", { enumerable: true, get: function () { return money_1.getCurrencyRule; } });
+Object.defineProperty(exports, "toProviderMinorAmount", { enumerable: true, get: function () { return money_1.toProviderMinorAmount; } });
+//# sourceMappingURL=contracts.js.map

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

@@ -0,0 +1,13 @@
+export interface PrismOperationErrorShape {
+    category: 'configuration' | 'authentication' | 'validation' | 'customer_action' | 'declined' | 'rate_limited' | 'network' | 'provider_server' | 'conflict' | 'unknown';
+    providerCode?: string;
+    providerRequestId?: string;
+    retryable: boolean;
+    outcome: 'definitely_not_applied' | 'applied' | 'ambiguous';
+    safeMessage: string;
+}
+export declare class PrismOperationError extends Error {
+    readonly shape: PrismOperationErrorShape;
+    constructor(shape: PrismOperationErrorShape, options?: ErrorOptions);
+}
+export declare function normalizePrismError(error: unknown): PrismOperationError;

package/dist/src/alphaweb/error.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismOperationError = void 0;
+exports.normalizePrismError = normalizePrismError;
+const errors_1 = require("../payments/errors");
+class PrismOperationError extends Error {
+    shape;
+    constructor(shape, options) {
+        super(shape.safeMessage, options);
+        this.name = 'PrismOperationError';
+        this.shape = Object.freeze({ ...shape });
+    }
+}
+exports.PrismOperationError = PrismOperationError;
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function recordOf(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function normalizePrismError(error) {
+    if (error instanceof PrismOperationError)
+        return error;
+    const details = recordOf(error);
+    const cause = recordOf(details.cause);
+    const status = Number((error instanceof errors_1.ConnectorError ? error.httpStatusCode : undefined) ??
+        details.statusCode ??
+        details.status ??
+        cause.statusCode ??
+        cause.status);
+    const code = (error instanceof errors_1.IntegrationError || error instanceof errors_1.ConnectorError
+        ? readString(error.errorCode)
+        : undefined) ??
+        readString(details.code) ??
+        readString(cause.code);
+    const name = (error instanceof Error ? readString(error.name) : undefined) ??
+        readString(details.name) ??
+        readString(cause.name);
+    const requestId = readString(details.requestId) ??
+        readString(details.request_id) ??
+        readString(cause.requestId) ??
+        readString(cause.request_id);
+    const normalizedCode = code?.toLowerCase() ?? '';
+    let category = 'unknown';
+    let retryable = false;
+    let outcome = 'ambiguous';
+    let safeMessage = 'The payment provider could not complete the request.';
+    if (error instanceof errors_1.IntegrationError) {
+        category = 'validation';
+        outcome = 'definitely_not_applied';
+        safeMessage = 'The payment request could not be created for this provider.';
+    }
+    else if (status === 401 || status === 403 || normalizedCode.includes('auth')) {
+        category = 'authentication';
+        outcome = 'definitely_not_applied';
+        safeMessage = 'The payment provider credentials are not authorized.';
+    }
+    else if (status === 400 || status === 404 || normalizedCode.includes('invalid')) {
+        category = 'validation';
+        outcome = 'definitely_not_applied';
+        safeMessage = 'The payment provider rejected the request parameters.';
+    }
+    else if (status === 402 || normalizedCode.includes('declin')) {
+        category = 'declined';
+        outcome = 'definitely_not_applied';
+        safeMessage = 'The payment method was declined.';
+    }
+    else if (status === 409) {
+        category = 'conflict';
+        retryable = true;
+        safeMessage = 'The payment result must be reconciled before retrying.';
+    }
+    else if (status === 429) {
+        category = 'rate_limited';
+        retryable = true;
+        safeMessage = 'The payment provider is temporarily rate limited.';
+    }
+    else if (Number.isFinite(status) && status >= 500) {
+        category = 'provider_server';
+        retryable = true;
+        safeMessage = 'The payment provider is temporarily unavailable.';
+    }
+    else if (error instanceof errors_1.ConnectorError ||
+        normalizedCode.includes('network') ||
+        normalizedCode.includes('timeout') ||
+        name === 'AbortError') {
+        category = 'network';
+        retryable = true;
+        safeMessage = 'The payment provider response was interrupted.';
+    }
+    return new PrismOperationError({
+        category,
+        ...(code ? { providerCode: code } : {}),
+        ...(requestId ? { providerRequestId: requestId } : {}),
+        retryable,
+        outcome,
+        safeMessage,
+    }, error instanceof Error ? { cause: error } : undefined);
+}
+//# sourceMappingURL=error.js.map

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

@@ -0,0 +1,3 @@
+export * from './contracts';
+export { PrismStripeConnector, verifyPrismStripeRuntimeCredential, } from './stripe-connector';
+export type { PrismStripeConnectorDependencies } from './stripe-connector';

package/dist/src/alphaweb/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPrismStripeRuntimeCredential = exports.PrismStripeConnector = void 0;
+__exportStar(require("./contracts"), exports);
+var stripe_connector_1 = require("./stripe-connector");
+Object.defineProperty(exports, "PrismStripeConnector", { enumerable: true, get: function () { return stripe_connector_1.PrismStripeConnector; } });
+Object.defineProperty(exports, "verifyPrismStripeRuntimeCredential", { enumerable: true, get: function () { return stripe_connector_1.verifyPrismStripeRuntimeCredential; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,28 @@
+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_PRISM_COMPATIBILITY_MANIFEST: Readonly<{
+    readonly release: "0.1.0-rc.27";
+    readonly upstreamCommit: "b07af7d9dac271de729548e74217ddcf895c602b";
+    readonly medusaRange: ">=2.17.2 <2.18.0";
+    readonly stripeApiVersion: "2026-06-24.dahlia";
+    readonly auditedUpstreamStripeApiVersion: "2022-11-15";
+    readonly stripeWebhookEvents: 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"];
+    readonly stripeWebhookEventSetSha256: "5f9eeb16bed529b9dcb66de5985ec34ab8a818a3d9980204dbadd495d409d428";
+    readonly stripeWebhookEventSetEncoding: "utf8-sorted-lf-v1";
+    readonly stripeJsContract: "payment-element-v1";
+    readonly webhookSchemaVersion: 1;
+    readonly reusableReferenceVersion: 1;
+    readonly normalizedStatusMappingVersion: 1;
+    readonly nativeAbiVersion: 1;
+    readonly nativeAbi: readonly ["linux-x64-gnu"];
+    readonly connectors: readonly ["stripe"];
+    readonly features: {
+        readonly oneTimePayment: true;
+        readonly futureUse: true;
+        readonly repeatPayment: true;
+        readonly webhookParse: true;
+        readonly webhookEndpointManagement: true;
+        readonly refundProjection: true;
+        readonly disputeProjection: true;
+    };
+}>;
+export type AlphaWebPrismCompatibilityManifest = typeof ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST;

package/dist/src/alphaweb/manifest.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST = exports.ALPHAWEB_STRIPE_WEBHOOK_EVENTS = void 0;
+exports.ALPHAWEB_STRIPE_WEBHOOK_EVENTS = Object.freeze([
+    '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',
+]);
+exports.ALPHAWEB_PRISM_COMPATIBILITY_MANIFEST = Object.freeze({
+    release: '0.1.0-rc.27',
+    upstreamCommit: 'b07af7d9dac271de729548e74217ddcf895c602b',
+    medusaRange: '>=2.17.2 <2.18.0',
+    stripeApiVersion: '2026-06-24.dahlia',
+    auditedUpstreamStripeApiVersion: '2022-11-15',
+    stripeWebhookEvents: exports.ALPHAWEB_STRIPE_WEBHOOK_EVENTS,
+    stripeWebhookEventSetSha256: '5f9eeb16bed529b9dcb66de5985ec34ab8a818a3d9980204dbadd495d409d428',
+    stripeWebhookEventSetEncoding: 'utf8-sorted-lf-v1',
+    stripeJsContract: 'payment-element-v1',
+    webhookSchemaVersion: 1,
+    reusableReferenceVersion: 1,
+    normalizedStatusMappingVersion: 1,
+    nativeAbiVersion: 1,
+    nativeAbi: ['linux-x64-gnu'],
+    connectors: ['stripe'],
+    features: {
+        oneTimePayment: true,
+        futureUse: true,
+        repeatPayment: true,
+        webhookParse: true,
+        webhookEndpointManagement: true,
+        refundProjection: true,
+        disputeProjection: true,
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,19 @@
+import type { PrismMoney } from './types';
+export interface CurrencyRule {
+    code: string;
+    exponent: 0 | 2 | 3;
+    stripeChargeRule: 'normal' | 'integer_with_trailing_zeros';
+}
+export declare function getCurrencyRule(currency: string): CurrencyRule;
+export declare function toProviderMinorAmount(input: {
+    medusaAmount: string | number | bigint;
+    currency: string;
+}): bigint;
+export declare function fromProviderMinorAmount(input: {
+    amountMinor: bigint | string;
+    currency: string;
+}): string;
+export declare function assertSafeProviderMoney(money: PrismMoney): {
+    amountMinor: number;
+    currency: string;
+};

package/dist/src/alphaweb/money.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrencyRule = getCurrencyRule;
+exports.toProviderMinorAmount = toProviderMinorAmount;
+exports.fromProviderMinorAmount = fromProviderMinorAmount;
+exports.assertSafeProviderMoney = assertSafeProviderMoney;
+const ZERO_DECIMAL = new Set([
+    'bif',
+    'clp',
+    'djf',
+    'gnf',
+    'jpy',
+    'kmf',
+    'krw',
+    'mga',
+    'pyg',
+    'rwf',
+    'vnd',
+    'vuv',
+    'xaf',
+    'xof',
+    'xpf',
+]);
+const THREE_DECIMAL = new Set(['bhd', 'jod', 'kwd', 'omr', 'tnd']);
+const SPECIAL_TRAILING_ZERO = new Set(['isk', 'ugx']);
+const CURRENCY_CODE = /^[a-z]{3}$/;
+const INTEGER = /^\d+$/;
+// Stripe's pinned API contract. Unknown ISO-like values are rejected here rather
+// than allowed to fail later, after a merchant operation has been claimed.
+const STRIPE_SUPPORTED_CURRENCIES = new Set([
+    'aed', 'afn', 'all', 'amd', 'ang', 'aoa', 'ars', 'aud', 'awg', 'azn', 'bam',
+    'bbd', 'bdt', 'bgn', 'bhd', 'bif', 'bmd', 'bnd', 'bob', 'brl', 'bsd', 'bwp', 'byn',
+    'bzd', 'cad', 'cdf', 'chf', 'clp', 'cny', 'cop', 'crc', 'cve', 'czk', 'djf',
+    'dkk', 'dop', 'dzd', 'egp', 'etb', 'eur', 'fjd', 'fkp', 'gbp', 'gel', 'gip',
+    'gmd', 'gnf', 'gtq', 'gyd', 'hkd', 'hnl', 'htg', 'huf', 'idr', 'ils', 'inr',
+    'isk', 'jmd', 'jod', 'jpy', 'kes', 'kgs', 'khr', 'kmf', 'krw', 'kwd', 'kyd',
+    'kzt', 'lak',
+    'lbp', 'lkr', 'lrd', 'lsl', 'mad', 'mdl', 'mga', 'mkd', 'mmk', 'mnt', 'mop',
+    'mru', 'mur', 'mvr', 'mwk', 'mxn', 'myr', 'mzn', 'nad', 'ngn', 'nio', 'nok',
+    'npr', 'nzd', 'pab', 'pen', 'pgk', 'php', 'pkr', 'pln', 'pyg', 'qar', 'ron',
+    'omr', 'rsd', 'rub', 'rwf', 'sar', 'sbd', 'scr', 'sek', 'sgd', 'shp', 'sle', 'sos',
+    'srd', 'stn', 'szl', 'thb', 'tjs', 'tnd', 'top', 'try', 'ttd', 'twd', 'tzs', 'uah',
+    'ugx', 'usd', 'uyu', 'uzs', 'vnd', 'vuv', 'wst', 'xaf', 'xcd', 'xof', 'xpf',
+    'yer', 'zar', 'zmw',
+]);
+function getCurrencyRule(currency) {
+    const code = currency.trim().toLowerCase();
+    if (!CURRENCY_CODE.test(code)) {
+        throw new RangeError(`Unsupported currency code: ${currency}`);
+    }
+    if (!STRIPE_SUPPORTED_CURRENCIES.has(code)) {
+        throw new RangeError(`Currency is not supported by the pinned Stripe contract: ${currency}`);
+    }
+    if (SPECIAL_TRAILING_ZERO.has(code)) {
+        return { code, exponent: 2, stripeChargeRule: 'integer_with_trailing_zeros' };
+    }
+    if (ZERO_DECIMAL.has(code)) {
+        return { code, exponent: 0, stripeChargeRule: 'normal' };
+    }
+    if (THREE_DECIMAL.has(code)) {
+        return { code, exponent: 3, stripeChargeRule: 'normal' };
+    }
+    return { code, exponent: 2, stripeChargeRule: 'normal' };
+}
+function decimalString(value) {
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new RangeError('Money must be finite.');
+        const plain = value.toString();
+        if (/[eE]/.test(plain))
+            throw new RangeError('Exponential money values are not accepted.');
+        return plain;
+    }
+    const trimmed = value.trim();
+    if (!/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+        throw new RangeError('Money must be a base-10 decimal value.');
+    }
+    return trimmed;
+}
+function toProviderMinorAmount(input) {
+    const rule = getCurrencyRule(input.currency);
+    const value = decimalString(input.medusaAmount);
+    if (value.startsWith('-'))
+        throw new RangeError('Payment amount cannot be negative.');
+    const [whole, fraction = ''] = value.split('.');
+    if (fraction.length > rule.exponent) {
+        throw new RangeError(`${rule.code.toUpperCase()} accepts at most ${rule.exponent} decimals.`);
+    }
+    const padded = fraction.padEnd(rule.exponent, '0');
+    const minor = BigInt(`${whole}${padded}`.replace(/^0+(?=\d)/, '') || '0');
+    if (rule.stripeChargeRule === 'integer_with_trailing_zeros' && minor % 100n !== 0n) {
+        throw new RangeError(`${rule.code.toUpperCase()} charge amounts must end in 00 minor units.`);
+    }
+    return minor;
+}
+function fromProviderMinorAmount(input) {
+    const rule = getCurrencyRule(input.currency);
+    if (typeof input.amountMinor === 'string' && !INTEGER.test(input.amountMinor)) {
+        throw new RangeError('Provider minor amount must be a non-negative integer.');
+    }
+    const minor = typeof input.amountMinor === 'bigint' ? input.amountMinor : BigInt(input.amountMinor);
+    if (minor < 0n)
+        throw new RangeError('Payment amount cannot be negative.');
+    if (rule.exponent === 0)
+        return minor.toString();
+    const digits = minor.toString().padStart(rule.exponent + 1, '0');
+    const splitAt = digits.length - rule.exponent;
+    return `${digits.slice(0, splitAt)}.${digits.slice(splitAt)}`;
+}
+function assertSafeProviderMoney(money) {
+    const rule = getCurrencyRule(money.currency);
+    if (!INTEGER.test(money.amountMinor)) {
+        throw new RangeError('Provider minor amount must be a non-negative integer string.');
+    }
+    const amount = BigInt(money.amountMinor);
+    if (amount <= 0n)
+        throw new RangeError('Provider payment amount must be positive.');
+    if (amount > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError('Provider payment amount exceeds the safe integer range.');
+    }
+    if (rule.stripeChargeRule === 'integer_with_trailing_zeros' && amount % 100n !== 0n) {
+        throw new RangeError(`${rule.code.toUpperCase()} charge amounts must end in 00 minor units.`);
+    }
+    return { amountMinor: Number(amount), currency: rule.code };
+}
+//# sourceMappingURL=money.js.map

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

@@ -0,0 +1,58 @@
+import { types } from '../payments/generated/proto';
+import type { PrismCancelInput, PrismCaptureInput, PrismCreateWebhookEndpointInput, PrismDeleteWebhookEndpointInput, PrismDisputeResult, PrismEstablishReusableReferenceInput, PrismFindPaymentInput, PrismFindRefundInput, PrismMerchantOperation, PrismPaymentResult, PrismRefundInput, PrismRefundResult, PrismRetrieveDisputeInput, PrismRetrieveRefundInput, PrismRetryPaymentInput, PrismReusableReferenceDerivation, PrismRetrieveWebhookEndpointInput, PrismRetrievePaymentInput, PrismStripeConnectorOptions, PrismStripeConnectorV1, PrismStripeRuntimeVerification, PrismStripeRuntimeVerificationInput, PrismUpdateWebhookEndpointInput, PrismWebhookEndpoint, PrismWebhookEndpointCreated, PrismWebhookParseInput, PrismWebhookParseResult } from './types';
+interface MerchantAuthenticationPort {
+    createClientAuthenticationToken(input: types.IMerchantAuthenticationServiceCreateClientAuthenticationTokenRequest): Promise<types.MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse>;
+}
+interface PaymentPort {
+    get(input: types.IPaymentServiceGetRequest): Promise<types.PaymentServiceGetResponse>;
+    capture(input: types.IPaymentServiceCaptureRequest): Promise<types.PaymentServiceCaptureResponse>;
+    void(input: types.IPaymentServiceVoidRequest): Promise<types.PaymentServiceVoidResponse>;
+    refund(input: types.IPaymentServiceRefundRequest): Promise<types.RefundResponse>;
+}
+interface RecurringPaymentPort {
+    charge(input: types.IRecurringPaymentServiceChargeRequest): Promise<types.RecurringPaymentServiceChargeResponse>;
+}
+interface EventPort {
+    handleEvent(input: types.IEventServiceHandleRequest): Promise<types.EventServiceHandleResponse>;
+}
+export interface PrismStripeConnectorDependencies {
+    merchantAuthentication: MerchantAuthenticationPort;
+    payments: PaymentPort;
+    recurringPayments: RecurringPaymentPort;
+    events: EventPort;
+    fetch: typeof fetch;
+}
+export declare class PrismStripeConnector implements PrismStripeConnectorV1 {
+    readonly options: Readonly<PrismStripeConnectorOptions>;
+    private readonly dependencies;
+    constructor(options: PrismStripeConnectorOptions, dependencies?: PrismStripeConnectorDependencies);
+    private validateOptions;
+    private assertOperation;
+    private recoverRepeatPayment;
+    private stripeRequest;
+    createPayment(input: PrismMerchantOperation): Promise<PrismPaymentResult>;
+    repeatPayment(input: PrismMerchantOperation): Promise<PrismPaymentResult>;
+    retryPayment(input: PrismRetryPaymentInput): Promise<PrismPaymentResult>;
+    retrievePayment(input: PrismRetrievePaymentInput): Promise<PrismPaymentResult>;
+    establishReusableReference(input: PrismEstablishReusableReferenceInput): Promise<PrismReusableReferenceDerivation>;
+    findPaymentsByMerchantOperation(input: PrismFindPaymentInput): Promise<PrismPaymentResult[]>;
+    capturePayment(input: PrismCaptureInput): Promise<PrismPaymentResult>;
+    cancelPayment(input: PrismCancelInput): Promise<PrismPaymentResult>;
+    refundPayment(input: PrismRefundInput): Promise<PrismRefundResult>;
+    retrieveRefund(input: PrismRetrieveRefundInput): Promise<PrismRefundResult>;
+    findRefundsByMerchantOperation(input: PrismFindRefundInput): Promise<PrismRefundResult[]>;
+    retrieveDispute(input: PrismRetrieveDisputeInput): Promise<PrismDisputeResult>;
+    parseWebhookEvent(input: PrismWebhookParseInput): Promise<PrismWebhookParseResult>;
+    createWebhookEndpoint(input: PrismCreateWebhookEndpointInput): Promise<PrismWebhookEndpointCreated>;
+    updateWebhookEndpoint(input: PrismUpdateWebhookEndpointInput): Promise<PrismWebhookEndpoint>;
+    deleteWebhookEndpoint(input: PrismDeleteWebhookEndpointInput): Promise<void>;
+    retrieveWebhookEndpoint(input: PrismRetrieveWebhookEndpointInput): Promise<PrismWebhookEndpoint>;
+    private normalizeEndpoint;
+}
+/**
+ * Verifies that one Stripe key pair resolves to the expected merchant account
+ * and that the pinned native Prism runtime can be constructed for it. Consumer
+ * applications receive only the verified account identity and mode.
+ */
+export declare function verifyPrismStripeRuntimeCredential(input: PrismStripeRuntimeVerificationInput, dependencies?: PrismStripeConnectorDependencies): Promise<PrismStripeRuntimeVerification>;
+export {};