@vue-stripe/vue-stripe 4.5.0 → 5.0.0

package/dist/types/components/VueStripeAddressElement.vue.d.ts

@@ -0,0 +1,105 @@
+import { StripeAddressElement as StripeAddressElementType, StripeAddressElementOptions, StripeAddressElementChangeEvent, StripeError } from '@stripe/stripe-js';
+import { DefineComponent, ExtractPropTypes, Ref, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue-demi';
+interface AddressElementWithEvents extends StripeAddressElementType {
+    on(eventType: string, handler: (...args: any[]) => void): this;
+    off(eventType: string, handler?: (...args: any[]) => void): this;
+    getValue(): Promise<Pick<StripeAddressElementChangeEvent, 'complete' | 'isNewAddress' | 'value'>>;
+}
+declare const _default: DefineComponent<ExtractPropTypes<{
+    options: {
+        type: () => StripeAddressElementOptions;
+        default: () => {
+            mode: "shipping";
+        };
+    };
+}>, {
+    addressRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    element: Ref<{
+        on: (eventType: string, handler: (...args: any[]) => void) => AddressElementWithEvents;
+        off: (eventType: string, handler?: (...args: any[]) => void) => AddressElementWithEvents;
+        getValue: () => Promise<Pick<StripeAddressElementChangeEvent, "complete" | "isNewAddress" | "value">>;
+        mount: (domElement: string | HTMLElement) => void;
+        blur: () => void;
+        clear: () => void;
+        destroy: () => void;
+        focus: () => void;
+        unmount: () => void;
+        once: {
+            (eventType: "change", handler: (event: StripeAddressElementChangeEvent) => any): StripeAddressElementType;
+            (eventType: "ready", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "focus", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "blur", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "escape", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "loaderror", handler: (event: {
+                elementType: "address";
+                error: StripeError;
+            }) => any): StripeAddressElementType;
+            (eventType: "loaderstart", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+        };
+        update: (options: Partial<StripeAddressElementOptions>) => StripeAddressElementType;
+    } | null, AddressElementWithEvents | {
+        on: (eventType: string, handler: (...args: any[]) => void) => AddressElementWithEvents;
+        off: (eventType: string, handler?: (...args: any[]) => void) => AddressElementWithEvents;
+        getValue: () => Promise<Pick<StripeAddressElementChangeEvent, "complete" | "isNewAddress" | "value">>;
+        mount: (domElement: string | HTMLElement) => void;
+        blur: () => void;
+        clear: () => void;
+        destroy: () => void;
+        focus: () => void;
+        unmount: () => void;
+        once: {
+            (eventType: "change", handler: (event: StripeAddressElementChangeEvent) => any): StripeAddressElementType;
+            (eventType: "ready", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "focus", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "blur", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "escape", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+            (eventType: "loaderror", handler: (event: {
+                elementType: "address";
+                error: StripeError;
+            }) => any): StripeAddressElementType;
+            (eventType: "loaderstart", handler: (event: {
+                elementType: "address";
+            }) => any): StripeAddressElementType;
+        };
+        update: (options: Partial<StripeAddressElementOptions>) => StripeAddressElementType;
+    } | null>;
+    getValue: () => Promise<Pick<StripeAddressElementChangeEvent, "value" | "complete" | "isNewAddress">>;
+    focus: () => void;
+    clear: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("blur" | "change" | "focus" | "ready" | "escape" | "loadError")[], "blur" | "change" | "focus" | "ready" | "escape" | "loadError", PublicProps, Readonly< ExtractPropTypes<{
+    options: {
+        type: () => StripeAddressElementOptions;
+        default: () => {
+            mode: "shipping";
+        };
+    };
+}>> & Readonly<{
+    onFocus?: (...args: any[]) => any;
+    onBlur?: (...args: any[]) => any;
+    onChange?: (...args: any[]) => any;
+    onReady?: (...args: any[]) => any;
+    onEscape?: (...args: any[]) => any;
+    onLoadError?: (...args: any[]) => any;
+}>, {
+    options: StripeAddressElementOptions;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=VueStripeAddressElement.vue.d.ts.map

package/dist/types/components/VueStripeAddressElement.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeAddressElement.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeAddressElement.vue"],"names":[],"mappings":";AAGA;AAqJA,OAAO,KAAK,EACV,oBAAoB,IAAI,wBAAwB,EAChD,2BAA2B,EAC3B,+BAA+B,EAChC,MAAM,mBAAmB,CAAA;AAK1B,UAAU,wBAAyB,SAAQ,wBAAwB;IAEjE,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAA;IAE9D,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAA;IAChE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,+BAA+B,EAAE,UAAU,GAAG,cAAc,GAAG,OAAO,CAAC,CAAC,CAAA;CAClG;;;cAMqB,MAAM,2BAA2B;;;;;;;;wBAVvC,MAAM,WAAW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;yBAExC,MAAM,YAAY,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;wBAC7C,OAAO,CAAC,IAAI,CAAC,+BAA+B,EAAE,UAAU,GAAG,cAAc,GAAG,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAHnF,MAAM,WAAW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;yBAExC,MAAM,YAAY,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;wBAC7C,OAAO,CAAC,IAAI,CAAC,+BAA+B,EAAE,UAAU,GAAG,cAAc,GAAG,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAO7E,MAAM,2BAA2B;;;;;;;;;;;;;;;AAJvD,wBA2HC"}

package/dist/types/components/VueStripeCardCvcElement.vue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../vue-demi';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("blur" | "change" | "focus" | "ready" | "escape")[], "blur" | "change" | "focus" | "ready" | "escape", PublicProps, Readonly< ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onFocus?: (...args: any[]) => any;
+    onBlur?: (...args: any[]) => any;
+    onChange?: (...args: any[]) => any;
+    onReady?: (...args: any[]) => any;
+    onEscape?: (...args: any[]) => any;
+}>, {
+    options: Record<string, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=VueStripeCardCvcElement.vue.d.ts.map

package/dist/types/components/VueStripeCardCvcElement.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeCardCvcElement.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeCardCvcElement.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAkDA,wBAIC"}

package/dist/types/components/VueStripeCardElement.vue.d.ts

@@ -0,0 +1,197 @@
+import { StripeCardElement as StripeCardElementType, StripeCardElementOptions, StripeCardElementChangeEvent, StripeError, StripeCardElementUpdateOptions } from '@stripe/stripe-js';
+import { DefineComponent, Ref, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue-demi';
+interface Props {
+    options?: StripeCardElementOptions;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        error?(_: {
+            error: string;
+        }): any;
+        loading?(_: {}): any;
+    };
+    refs: {
+        elementRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<Props, {
+    element: Ref<{
+        mount: (domElement: string | HTMLElement) => void;
+        blur: () => void;
+        clear: () => void;
+        destroy: () => void;
+        focus: () => void;
+        unmount: () => void;
+        on: {
+            (eventType: "change", handler: (event: StripeCardElementChangeEvent) => any): StripeCardElementType;
+            (eventType: "ready", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "focus", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "blur", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "escape", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "networkschange", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "loaderror", handler: (event: {
+                elementType: "card";
+                error: StripeError;
+            }) => any): StripeCardElementType;
+        };
+        once: {
+            (eventType: "change", handler: (event: StripeCardElementChangeEvent) => any): StripeCardElementType;
+            (eventType: "ready", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "focus", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "blur", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "escape", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "networkschange", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "loaderror", handler: (event: {
+                elementType: "card";
+                error: StripeError;
+            }) => any): StripeCardElementType;
+        };
+        off: {
+            (eventType: "change", handler?: (event: StripeCardElementChangeEvent) => any): StripeCardElementType;
+            (eventType: "ready", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "focus", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "blur", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "escape", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "networkschange", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "loaderror", handler?: (event: {
+                elementType: "card";
+                error: StripeError;
+            }) => any): StripeCardElementType;
+        };
+        update: (options: StripeCardElementUpdateOptions) => void;
+    } | null, StripeCardElementType | {
+        mount: (domElement: string | HTMLElement) => void;
+        blur: () => void;
+        clear: () => void;
+        destroy: () => void;
+        focus: () => void;
+        unmount: () => void;
+        on: {
+            (eventType: "change", handler: (event: StripeCardElementChangeEvent) => any): StripeCardElementType;
+            (eventType: "ready", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "focus", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "blur", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "escape", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "networkschange", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "loaderror", handler: (event: {
+                elementType: "card";
+                error: StripeError;
+            }) => any): StripeCardElementType;
+        };
+        once: {
+            (eventType: "change", handler: (event: StripeCardElementChangeEvent) => any): StripeCardElementType;
+            (eventType: "ready", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "focus", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "blur", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "escape", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "networkschange", handler: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "loaderror", handler: (event: {
+                elementType: "card";
+                error: StripeError;
+            }) => any): StripeCardElementType;
+        };
+        off: {
+            (eventType: "change", handler?: (event: StripeCardElementChangeEvent) => any): StripeCardElementType;
+            (eventType: "ready", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "focus", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "blur", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "escape", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "networkschange", handler?: (event: {
+                elementType: "card";
+            }) => any): StripeCardElementType;
+            (eventType: "loaderror", handler?: (event: {
+                elementType: "card";
+                error: StripeError;
+            }) => any): StripeCardElementType;
+        };
+        update: (options: StripeCardElementUpdateOptions) => void;
+    } | null>;
+    loading: Ref<boolean, boolean>;
+    error: Ref<string | null, string | null>;
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+    clear: () => void | undefined;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    blur: () => any;
+    change: (event: StripeCardElementChangeEvent) => any;
+    focus: () => any;
+    ready: (element: StripeCardElementType) => any;
+    escape: () => any;
+}, string, PublicProps, Readonly<Props> & Readonly<{
+    onBlur?: () => any;
+    onChange?: (event: StripeCardElementChangeEvent) => any;
+    onFocus?: () => any;
+    onReady?: (element: StripeCardElementType) => any;
+    onEscape?: () => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    elementRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=VueStripeCardElement.vue.d.ts.map

package/dist/types/components/VueStripeCardElement.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeCardElement.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeCardElement.vue"],"names":[],"mappings":";AA4NA,OAAO,KAAK,EACV,iBAAiB,IAAI,qBAAqB,EAC1C,wBAAwB,EACxB,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAI1B,UAAU,KAAK;IACb,OAAO,CAAC,EAAE,wBAAwB,CAAA;CACnC;AA4ID,iBAAS,cAAc;WA+DT,OAAO,IAA6B;;;;YAZvB,GAAG;yBACD,GAAG;;;;;;EAgB/B;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAOpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/types/components/VueStripeCardExpiryElement.vue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../vue-demi';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("blur" | "change" | "focus" | "ready" | "escape")[], "blur" | "change" | "focus" | "ready" | "escape", PublicProps, Readonly< ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onFocus?: (...args: any[]) => any;
+    onBlur?: (...args: any[]) => any;
+    onChange?: (...args: any[]) => any;
+    onReady?: (...args: any[]) => any;
+    onEscape?: (...args: any[]) => any;
+}>, {
+    options: Record<string, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=VueStripeCardExpiryElement.vue.d.ts.map

package/dist/types/components/VueStripeCardExpiryElement.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeCardExpiryElement.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeCardExpiryElement.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAkDA,wBAIC"}

package/dist/types/components/VueStripeCardNumberElement.vue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../vue-demi';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("blur" | "change" | "focus" | "ready" | "escape")[], "blur" | "change" | "focus" | "ready" | "escape", PublicProps, Readonly< ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onFocus?: (...args: any[]) => any;
+    onBlur?: (...args: any[]) => any;
+    onChange?: (...args: any[]) => any;
+    onReady?: (...args: any[]) => any;
+    onEscape?: (...args: any[]) => any;
+}>, {
+    options: Record<string, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=VueStripeCardNumberElement.vue.d.ts.map

package/dist/types/components/VueStripeCardNumberElement.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeCardNumberElement.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeCardNumberElement.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAwDA,wBAIC"}

package/dist/types/components/VueStripeCheckout.vue.d.ts

@@ -0,0 +1,50 @@
+import { RedirectToCheckoutOptions } from '@stripe/stripe-js';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue-demi';
+interface Props {
+    sessionId?: string;
+    priceId?: string;
+    mode?: 'payment' | 'subscription';
+    successUrl?: string;
+    cancelUrl?: string;
+    customerEmail?: string;
+    clientReferenceId?: string;
+    submitType?: 'auto' | 'book' | 'donate' | 'pay';
+    options?: Partial<RedirectToCheckoutOptions>;
+    buttonText?: string;
+    loadingText?: string;
+    disabled?: boolean;
+    buttonClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        loading?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    error: (error: Error) => any;
+    click: () => any;
+    success: () => any;
+}, string, PublicProps, Readonly<Props> & Readonly<{
+    onError?: (error: Error) => any;
+    onClick?: () => any;
+    onSuccess?: () => any;
+}>, {
+    mode: "payment" | "subscription";
+    buttonText: string;
+    loadingText: string;
+    disabled: boolean;
+    buttonClass: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=VueStripeCheckout.vue.d.ts.map

package/dist/types/components/VueStripeCheckout.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeCheckout.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeCheckout.vue"],"names":[],"mappings":";AA+JA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAIlE,UAAU,KAAK;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,SAAS,GAAG,cAAc,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAA;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAA;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAyFD,iBAAS,cAAc;WA2CT,OAAO,IAA6B;;yBAXrB,GAAG;yBACH,GAAG;;;;EAe/B;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;UAjKZ,SAAS,GAAG,cAAc;gBAOpB,MAAM;iBACL,MAAM;cACT,OAAO;iBACJ,MAAM;gGAgKpB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAYpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/types/components/VueStripeElements.vue.d.ts

@@ -0,0 +1,90 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue-demi';
+type ElementsOptions = Record<string, any>;
+/**
+ * Mode for Payment Element - determines the type of intent
+ * - 'payment': For PaymentIntent (one-time payments)
+ * - 'setup': For SetupIntent (saving payment methods for future use)
+ * - 'subscription': For Subscription billing
+ */
+type ElementsMode = 'payment' | 'setup' | 'subscription';
+/**
+ * Indicates intent to save payment method for future use
+ * - 'off_session': Save for off-session payments (e.g., recurring charges)
+ * - 'on_session': Save for on-session payments (customer present)
+ */
+type SetupFutureUsage = 'off_session' | 'on_session';
+/**
+ * Controls when to capture funds from customer's account
+ * - 'automatic': Capture automatically after authorization
+ * - 'automatic_async': Capture automatically with async processing
+ * - 'manual': Capture manually via API call
+ */
+type CaptureMethod = 'automatic' | 'automatic_async' | 'manual';
+interface Props {
+    /**
+     * Client secret from PaymentIntent or SetupIntent.
+     * When provided, Elements will use the intent-based flow.
+     * When omitted, use mode/currency/amount for deferred intent creation.
+     */
+    clientSecret?: string | undefined;
+    /**
+     * Mode for deferred intent creation (without clientSecret).
+     * Required when clientSecret is not provided.
+     * - 'payment': One-time payment
+     * - 'setup': Save payment method for future
+     * - 'subscription': Recurring billing
+     */
+    mode?: ElementsMode | undefined;
+    /**
+     * Currency code (e.g., 'usd', 'eur') for deferred intent creation.
+     * Required when using mode without clientSecret.
+     */
+    currency?: string | undefined;
+    /**
+     * Amount in smallest currency unit (e.g., cents for USD).
+     * Required for 'payment' and 'subscription' modes.
+     * Shown in Apple Pay, Google Pay, and BNPL UIs.
+     */
+    amount?: number | undefined;
+    /**
+     * Indicates intent to save payment method for future use.
+     * When set, displays additional input fields and mandates as needed.
+     */
+    setupFutureUsage?: SetupFutureUsage | undefined;
+    /**
+     * Controls when to capture funds from customer's account.
+     */
+    captureMethod?: CaptureMethod | undefined;
+    /**
+     * List of payment method types to display.
+     * Omit to use Dashboard payment method settings.
+     */
+    paymentMethodTypes?: string[] | undefined;
+    /**
+     * Additional options passed to stripe.elements().
+     * See Stripe documentation for all available options.
+     */
+    options?: ElementsOptions | undefined;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        error?(_: {
+            error: string;
+        }): any;
+        loading?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=VueStripeElements.vue.d.ts.map

package/dist/types/components/VueStripeElements.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VueStripeElements.vue.d.ts","sourceRoot":"","sources":["../../../src/components/VueStripeElements.vue"],"names":[],"mappings":";AA0PA,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAE1C;;;;;GAKG;AACH,KAAK,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,cAAc,CAAA;AAExD;;;;GAIG;AACH,KAAK,gBAAgB,GAAG,aAAa,GAAG,YAAY,CAAA;AAEpD;;;;;GAKG;AACH,KAAK,aAAa,GAAG,WAAW,GAAG,iBAAiB,GAAG,QAAQ,CAAA;AAE/D,UAAU,KAAK;IACb;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAA;IAC/C;;OAEG;IACH,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;IACzC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;IACzC;;;OAGG;IACH,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAA;CACtC;AAsHD,iBAAS,cAAc;WAuDT,OAAO,IAA6B;;;;YAZvB,GAAG;yBACD,GAAG;yBACH,GAAG;;;;EAe/B;AAUD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,+SAMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAOpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}