@8medusa/utils 2.7.0

package/dist/payment/abstract-payment-provider.d.ts

@@ -0,0 +1,518 @@
+import { IPaymentProvider, ProviderWebhookPayload, WebhookActionResult, CapturePaymentInput, CapturePaymentOutput, AuthorizePaymentInput, AuthorizePaymentOutput, CancelPaymentInput, CancelPaymentOutput, InitiatePaymentInput, InitiatePaymentOutput, DeletePaymentInput, DeletePaymentOutput, GetPaymentStatusInput, GetPaymentStatusOutput, RefundPaymentInput, RefundPaymentOutput, RetrievePaymentInput, RetrievePaymentOutput, UpdatePaymentInput, UpdatePaymentOutput } from "@8medusa/types";
+export declare abstract class AbstractPaymentProvider<TConfig = Record<string, unknown>> implements IPaymentProvider {
+    /**
+     * @ignore
+     */
+    protected readonly config: TConfig;
+    /**
+     * @ignore
+     */
+    protected readonly container: Record<string, unknown>;
+    /**
+     * This method validates the options of the provider set in `medusa-config.ts`.
+     * Implementing this method is optional. It's useful if your provider requires custom validation.
+     *
+     * If the options aren't valid, throw an error.
+     *
+     * @param options - The provider's options.
+     *
+     * @example
+     * class MyPaymentProviderService extends AbstractPaymentProvider<Options> {
+     *   static validateOptions(options: Record<any, any>) {
+     *     if (!options.apiKey) {
+     *       throw new MedusaError(
+     *         MedusaError.Types.INVALID_DATA,
+     *         "API key is required in the provider's options."
+     *       )
+     *     }
+     *   }
+     * }
+     */
+    static validateOptions(options: Record<any, any>): void | never;
+    /**
+     * The constructor allows you to access resources from the [module's container](https://docs.medusajs.com/learn/fundamentals/modules/container)
+     * using the first parameter, and the module's options using the second parameter.
+     *
+     * :::note
+     *
+     * A module's options are passed when you register it in the Medusa application.
+     *
+     * :::
+     *
+     * @param {Record<string, unknown>} cradle - The module's container cradle used to resolve resources.
+     * @param {Record<string, unknown>} config - The options passed to the Payment Module provider.
+     * @typeParam TConfig - The type of the provider's options passed as a second parameter.
+     *
+     * @example
+     * import { AbstractPaymentProvider } from "@8medusa/framework/utils"
+     * import { Logger } from "@8medusa/framework/types"
+     *
+     * type Options = {
+     *   apiKey: string
+     * }
+     *
+     * type InjectedDependencies = {
+     *   logger: Logger
+     * }
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<Options> {
+     *   protected logger_: Logger
+     *   protected options_: Options
+     *   // assuming you're initializing a client
+     *   protected client
+     *
+     *   constructor(
+     *     container: InjectedDependencies,
+     *     options: Options
+     *   ) {
+     *     super(container, options)
+     *
+     *     this.logger_ = container.logger
+     *     this.options_ = options
+     *
+     *     // TODO initialize your client
+     *   }
+     *   // ...
+     * }
+     *
+     * export default MyPaymentProviderService
+     */
+    protected constructor(cradle: Record<string, unknown>, 
+    /**
+     * @ignore
+     */
+    config?: TConfig);
+    /**
+     * @ignore
+     */
+    static _isPaymentProvider: boolean;
+    /**
+     * @ignore
+     */
+    static isPaymentProvider(object: any): boolean;
+    /**
+     * Each payment provider has a unique identifier defined in its class. The provider's ID
+     * will be stored as `pp_{identifier}_{id}`, where `{id}` is the provider's `id`
+     * property in the `medusa-config.ts`.
+     *
+     * @example
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   static identifier = "my-payment"
+     *   // ...
+     * }
+     */
+    static identifier: string;
+    /**
+     * @ignore
+     *
+     * Return a unique identifier to retrieve the payment plugin provider
+     */
+    getIdentifier(): string;
+    /**
+     * This method is used to capture a payment. The payment is captured in one of the following scenarios:
+     *
+     * - The {@link authorizePayment} method returns the status `captured`, which automatically executed this method after authorization.
+     * - The merchant requests to capture the payment after its associated payment session was authorized.
+     * - A webhook event occurred that instructs the payment provider to capture the payment session. Learn more about handing webhook events in [this guide](https://docs.medusajs.com/resources/commerce-modules/payment/webhook-events).
+     *
+     * In this method, use the third-party provider to capture the payment.
+     *
+     * @param input - The input to capture the payment. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The new data to store in the payment's `data` property. Throws in case of an error.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   CapturePaymentInput,
+     *   CapturePaymentOutput,
+     * } from "@8medusa/framework/types"
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async capturePayment(
+     *     input: CapturePaymentInput
+     *   ): Promise<CapturePaymentOutput> {
+     *     const externalId = input.data?.id
+     *
+     *       // assuming you have a client that captures the payment
+     *     const newData = await this.client.capturePayment(externalId)
+     *     return {data: newData}
+     *   }
+     *   // ...
+     * }
+     */
+    abstract capturePayment(input: CapturePaymentInput): Promise<CapturePaymentOutput>;
+    /**
+     * This method authorizes a payment session. When authorized successfully, a payment is created by the Payment
+     * Module which can be later captured using the {@link capturePayment} method.
+     *
+     * Refer to [this guide](https://docs.medusajs.com/resources/commerce-modules/payment/payment-flow#3-authorize-payment-session)
+     * to learn more about how this fits into the payment flow and how to handle required actions.
+     *
+     * To automatically capture the payment after authorization, return the status `captured`.
+     *
+     * @param input - The input to authorize the payment. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The status of the authorization, along with the `data` field about the payment. Throws in case of an error.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   AuthorizePaymentInput,
+     *   AuthorizePaymentOutput,
+     *   PaymentSessionStatus
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async authorizePayment(
+     *     input: AuthorizePaymentInput
+     *   ): Promise<AuthorizePaymentOutput> {
+     *     const externalId = input.data?.id
+     *
+     *     // assuming you have a client that authorizes the payment
+     *     const paymentData = await this.client.authorizePayment(externalId)
+     *
+     *     return {
+     *       data: paymentData,
+     *       status: "authorized"
+     *     }
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract authorizePayment(input: AuthorizePaymentInput): Promise<AuthorizePaymentOutput>;
+    /**
+     * This method cancels a payment.
+     *
+     * @param input - The input to cancel the payment. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The new data to store in the payment's `data` property, if any. Throws in case of an error.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   PaymentProviderError,
+     *   PaymentProviderSessionResponse,
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async cancelPayment(
+     *     input: CancelPaymentInput
+     *   ): Promise<CancelPaymentOutput> {
+     *     const externalId = input.data?.id
+     *
+     *     // assuming you have a client that cancels the payment
+     *     const paymentData = await this.client.cancelPayment(externalId)
+     *     return { data: paymentData }
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract cancelPayment(input: CancelPaymentInput): Promise<CancelPaymentOutput>;
+    /**
+     * This method is used when a payment session is created. It can be used to initiate the payment
+     * in the third-party session, before authorizing or capturing the payment later.
+     *
+     * @param input - The input to create the payment session.
+     * @returns The new data to store in the payment's `data` property. Throws in case of an error.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   InitiatePaymentInput,
+     *   InitiatePaymentOutput,
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async initiatePayment(
+     *     input: InitiatePaymentInput
+     *   ): Promise<InitiatePaymentOutput> {
+     *     const {
+     *       amount,
+     *       currency_code,
+     *       context: customerDetails
+     *     } = input
+     *
+     *     // assuming you have a client that initializes the payment
+     *     const response = await this.client.init(
+     *       amount, currency_code, customerDetails
+     *     )
+     *
+     *     return {
+     *       id: response.id,
+     *       data: response,
+     *     }
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract initiatePayment(input: InitiatePaymentInput): Promise<InitiatePaymentOutput>;
+    /**
+     * This method is used when a payment session is deleted, which can only happen if it isn't authorized, yet.
+     *
+     * Use this to delete or cancel the payment in the third-party service.
+     *
+     * @param input - The input to delete the payment session. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The new data to store in the payment's `data` property, if any. Throws in case of an error.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   DeletePaymentInput,
+     *   DeletePaymentOutput,
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async deletePayment(
+     *     input: DeletePaymentInput
+     *   ): Promise<DeletePaymentOutput> {
+     *     const externalId = input.data?.id
+     *
+     *     // assuming you have a client that cancels the payment
+     *     await this.client.cancelPayment(externalId)
+     *     return {}
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract deletePayment(input: DeletePaymentInput): Promise<DeletePaymentOutput>;
+    /**
+     * This method gets the status of a payment session based on the status in the third-party integration.
+     *
+     * @param input - The input to get the payment status. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The payment session's status. It can also return additional `data` from the payment provider.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   GetPaymentStatusInput,
+     *   GetPaymentStatusOutput,
+     *   PaymentSessionStatus
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async getPaymentStatus(
+     *     input: GetPaymentStatusInput
+     *   ): Promise<GetPaymentStatusOutput> {
+     *     const externalId = input.data?.id
+     *
+     *     // assuming you have a client that retrieves the payment status
+     *     const status = await this.client.getStatus(externalId)
+     *
+     *     switch (status) {
+     *       case "requires_capture":
+     *           return {status: "authorized"}
+     *         case "success":
+     *           return {status: "captured"}
+     *         case "canceled":
+     *           return {status: "canceled"}
+     *         default:
+     *           return {status: "pending"}
+     *      }
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract getPaymentStatus(input: GetPaymentStatusInput): Promise<GetPaymentStatusOutput>;
+    /**
+     * This method refunds an amount of a payment previously captured.
+     *
+     * @param input - The input to refund the payment. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The new data to store in the payment's `data` property, or an error object.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   RefundPaymentInput,
+     *   RefundPaymentOutput,
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async refundPayment(
+     *     input: RefundPaymentInput
+     *   ): Promise<RefundPaymentOutput> {
+     *     const externalId = input.data?.id
+     *
+     *     // assuming you have a client that refunds the payment
+     *     const newData = await this.client.refund(
+     *         externalId,
+     *         input.amount
+     *       )
+     *
+     *     return {data: newData}
+     *   }
+     *   // ...
+     * }
+     */
+    abstract refundPayment(input: RefundPaymentInput): Promise<RefundPaymentOutput>;
+    /**
+     * Retrieves the payment's data from the third-party service.
+     *
+     * @param input - The input to retrieve the payment. The `data` field should contain the data from the payment provider when the payment was created.
+     * @returns The payment's data as found in the the payment provider.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   RetrievePaymentInput,
+     *   RetrievePaymentOutput,
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async retrievePayment(
+     *     input: RetrievePaymentInput
+     *   ): Promise<RetrievePaymentOutput> {
+     *     const externalId = input.data?.id
+     *
+     *     // assuming you have a client that retrieves the payment
+     *     return await this.client.retrieve(externalId)
+     *   }
+     *   // ...
+     * }
+     */
+    abstract retrievePayment(input: RetrievePaymentInput): Promise<RetrievePaymentOutput>;
+    /**
+     * Update a payment in the third-party service that was previously initiated with the {@link initiatePayment} method.
+     *
+     * @param input - The input to update the payment. The `data` field should contain the data from the payment provider. when the payment was created.
+     * @returns The new data to store in the payment's `data` property. Throws in case of an error.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   UpdatePaymentInput,
+     *   UpdatePaymentOutput,
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async updatePayment(
+     *     input: UpdatePaymentInput
+     *   ): Promise<UpdatePaymentOutput> {
+     *     const { amount, currency_code, context } = input
+     *     const externalId = input.data?.id
+     *
+     *     // Validate context.customer
+     *     if (!context || !context.customer) {
+     *       throw new Error("Context must include a valid customer.");
+     *     }
+     *
+     *     // assuming you have a client that updates the payment
+     *     const response = await this.client.update(
+     *       externalId,
+     *         {
+     *           amount,
+     *           currency_code,
+     *           context.customer
+     *         }
+     *       )
+     *
+     *     return response
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract updatePayment(input: UpdatePaymentInput): Promise<UpdatePaymentOutput>;
+    /**
+     * This method is executed when a webhook event is received from the third-party payment provider. Use it
+     * to process the action of the payment provider.
+     *
+     * Learn more in [this documentation](https://docs.medusajs.com/resources/commerce-modules/payment/webhook-events)
+     *
+     * @param data - The webhook event's data
+     * @returns The webhook result. If the `action`'s value is `captured`, the payment is captured within Medusa as well.
+     * If the `action`'s value is `authorized`, the associated payment session is authorized within Medusa.
+     *
+     * @example
+     * // other imports...
+     * import {
+     *   BigNumber
+     * } from "@8medusa/framework/utils"
+     * import {
+     *   ProviderWebhookPayload,
+     *   WebhookActionResult
+     * } from "@8medusa/framework/types"
+     *
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<
+     *   Options
+     * > {
+     *   async getWebhookActionAndData(
+     *     payload: ProviderWebhookPayload["payload"]
+     *   ): Promise<WebhookActionResult> {
+     *     const {
+     *       data,
+     *       rawData,
+     *       headers
+     *     } = payload
+     *
+     *     try {
+     *       switch(data.event_type) {
+     *         case "authorized_amount":
+     *           return {
+     *             action: "authorized",
+     *             data: {
+     *               session_id: (data.metadata as Record<string, any>).session_id,
+     *               amount: new BigNumber(data.amount as number)
+     *             }
+     *           }
+     *         case "success":
+     *           return {
+     *             action: "captured",
+     *             data: {
+     *               session_id: (data.metadata as Record<string, any>).session_id,
+     *               amount: new BigNumber(data.amount as number)
+     *             }
+     *           }
+     *         default:
+     *           return {
+     *             action: "not_supported"
+     *           }
+     *       }
+     *     } catch (e) {
+     *       return {
+     *         action: "failed",
+     *         data: {
+     *           session_id: (data.metadata as Record<string, any>).session_id,
+     *           amount: new BigNumber(data.amount as number)
+     *         }
+     *       }
+     *     }
+     *   }
+     *
+     *   // ...
+     * }
+     */
+    abstract getWebhookActionAndData(data: ProviderWebhookPayload["payload"]): Promise<WebhookActionResult>;
+}
+//# sourceMappingURL=abstract-payment-provider.d.ts.map

package/dist/payment/abstract-payment-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-payment-provider.d.ts","sourceRoot":"","sources":["../../src/payment/abstract-payment-provider.ts"],"names":[],"mappings":"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"}

package/dist/payment/abstract-payment-provider.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractPaymentProvider = void 0;
+class AbstractPaymentProvider {
+    /**
+     * This method validates the options of the provider set in `medusa-config.ts`.
+     * Implementing this method is optional. It's useful if your provider requires custom validation.
+     *
+     * If the options aren't valid, throw an error.
+     *
+     * @param options - The provider's options.
+     *
+     * @example
+     * class MyPaymentProviderService extends AbstractPaymentProvider<Options> {
+     *   static validateOptions(options: Record<any, any>) {
+     *     if (!options.apiKey) {
+     *       throw new MedusaError(
+     *         MedusaError.Types.INVALID_DATA,
+     *         "API key is required in the provider's options."
+     *       )
+     *     }
+     *   }
+     * }
+     */
+    static validateOptions(options) { }
+    /**
+     * The constructor allows you to access resources from the [module's container](https://docs.medusajs.com/learn/fundamentals/modules/container)
+     * using the first parameter, and the module's options using the second parameter.
+     *
+     * :::note
+     *
+     * A module's options are passed when you register it in the Medusa application.
+     *
+     * :::
+     *
+     * @param {Record<string, unknown>} cradle - The module's container cradle used to resolve resources.
+     * @param {Record<string, unknown>} config - The options passed to the Payment Module provider.
+     * @typeParam TConfig - The type of the provider's options passed as a second parameter.
+     *
+     * @example
+     * import { AbstractPaymentProvider } from "@8medusa/framework/utils"
+     * import { Logger } from "@8medusa/framework/types"
+     *
+     * type Options = {
+     *   apiKey: string
+     * }
+     *
+     * type InjectedDependencies = {
+     *   logger: Logger
+     * }
+     *
+     * class MyPaymentProviderService extends AbstractPaymentProvider<Options> {
+     *   protected logger_: Logger
+     *   protected options_: Options
+     *   // assuming you're initializing a client
+     *   protected client
+     *
+     *   constructor(
+     *     container: InjectedDependencies,
+     *     options: Options
+     *   ) {
+     *     super(container, options)
+     *
+     *     this.logger_ = container.logger
+     *     this.options_ = options
+     *
+     *     // TODO initialize your client
+     *   }
+     *   // ...
+     * }
+     *
+     * export default MyPaymentProviderService
+     */
+    constructor(cradle, 
+    /**
+     * @ignore
+     */
+    config = {} // eslint-disable-next-line @typescript-eslint/no-empty-function
+    ) {
+        this.config = config;
+        this.container = cradle;
+    }
+    /**
+     * @ignore
+     */
+    static isPaymentProvider(object) {
+        return object?.constructor?._isPaymentProvider;
+    }
+    /**
+     * @ignore
+     *
+     * Return a unique identifier to retrieve the payment plugin provider
+     */
+    getIdentifier() {
+        const ctr = this.constructor;
+        if (!ctr.identifier) {
+            throw new Error(`Missing static property "identifier".`);
+        }
+        return ctr.identifier;
+    }
+}
+exports.AbstractPaymentProvider = AbstractPaymentProvider;
+/**
+ * @ignore
+ */
+AbstractPaymentProvider._isPaymentProvider = true;
+//# sourceMappingURL=abstract-payment-provider.js.map

package/dist/payment/abstract-payment-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-payment-provider.js","sourceRoot":"","sources":["../../src/payment/abstract-payment-provider.ts"],"names":[],"mappings":";;;AAwBA,MAAsB,uBAAuB;IAO3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,eAAe,CAAC,OAAyB,IAAiB,CAAC;IAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,YACE,MAA+B;IAC/B;;OAEG;IACgB,SAAkB,EAAa,CAAC,gEAAgE;;QAAhG,WAAM,GAAN,MAAM,CAAyB;QAElD,IAAI,CAAC,SAAS,GAAG,MAAM,CAAA;IACzB,CAAC;IAOD;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,MAAM;QAC7B,OAAO,MAAM,EAAE,WAAW,EAAE,kBAAkB,CAAA;IAChD,CAAC;IAiBD;;;;OAIG;IACI,aAAa;QAClB,MAAM,GAAG,GAAG,IAAI,CAAC,WAA6C,CAAA;QAE9D,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;QAC1D,CAAC;QAED,OAAO,GAAG,CAAC,UAAU,CAAA;IACvB,CAAC;;AA/HH,0DAkjBC;AA3dC;;GAEG;AACI,0CAAkB,GAAG,IAAI,CAAA"}

package/dist/payment/events.d.ts

@@ -0,0 +1,5 @@
+export declare const PaymentEvents: {
+    CAPTURED: string;
+    REFUNDED: string;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/payment/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/payment/events.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;CAGzB,CAAA"}

package/dist/payment/events.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentEvents = void 0;
+exports.PaymentEvents = {
+    CAPTURED: "payment.captured",
+    REFUNDED: "payment.refunded",
+};
+//# sourceMappingURL=events.js.map

package/dist/payment/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/payment/events.ts"],"names":[],"mappings":";;;AAAa,QAAA,aAAa,GAAG;IAC3B,QAAQ,EAAE,kBAAkB;IAC5B,QAAQ,EAAE,kBAAkB;CAC7B,CAAA"}

package/dist/payment/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./abstract-payment-provider";
+export * from "./events";
+export * from "./payment-collection";
+export * from "./payment-session";
+export * from "./webhook";
+//# sourceMappingURL=index.d.ts.map

package/dist/payment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/payment/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,UAAU,CAAA;AACxB,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA"}

package/dist/payment/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 });
+__exportStar(require("./abstract-payment-provider"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./payment-collection"), exports);
+__exportStar(require("./payment-session"), exports);
+__exportStar(require("./webhook"), exports);
+//# sourceMappingURL=index.js.map