@lana-commerce/core 11.0.0

package/types/modules/customer.d.ts

@@ -0,0 +1,624 @@
+import { Event, Store } from "effector";
+import type { Stripe, StripeCardElement, StripeCardNumberElement } from "@stripe/stripe-js";
+import type { CartVariantFragment, CustomerBalanceFragment, CustomerBalanceHistoryFragment, CustomerFavoriteFragment, CustomerFragment, CustomerOAuthProviderKind, CustomerOrderBriefFragment, CustomerOrderFulfillmentFragment, CustomerOrderFullFragment, CustomerPaymentSourceFragment, CustomerReturnBriefFragment, CustomerReturnFullFragment, CustomerReturnPolicyFragment, CustomerSubscriptionBriefFragment, CustomerSubscriptionFullFragment, IPAndUAInfoFragment, ReturnReasonFragment, ReturnReasonType, StorefrontCustomerFavoriteCreate, StorefrontCustomerFavoriteModify, SubscriptionParam } from "../graphql/types.js";
+import type { Dict, ListItem } from "../commonTypes.js";
+import { GraphQLOpts, RequestResponseError } from "../request.js";
+import { InvalidInputField } from "../mapInvalidInput.js";
+import { StripeCVCError, StripeExpiryError, StripeNumberError } from "../stripeError.js";
+import { Validator } from "../effector/validator.js";
+export type MessageType = "favorite_added" | "favorite_deleted" | "favorite_modified" | "oauth2_connected" | "oauth2_disconnected";
+export interface CustomerInfo {
+    customer: CustomerFragment;
+    favorites: {
+        id: string;
+        variantID: string;
+        inventoryNotification: boolean;
+        priceNotification: boolean;
+    }[];
+}
+export declare function createVariantMap(order: CustomerOrderFullFragment): Dict<CartVariantFragment>;
+type CommonPageParam = {
+    action: "push" | "pop" | "push_redirect" | "pop_redirect";
+};
+type OrderPageParam = CommonPageParam & {
+    kind: "order";
+    orderID: string;
+};
+type SubscriptionPageParam = CommonPageParam & {
+    kind: "subscription";
+    subscriptionID: string;
+};
+type ReturnPageParam = CommonPageParam & {
+    kind: "return";
+    returnID: string;
+};
+type CreateReturnPageParam = CommonPageParam & {
+    kind: "create_return";
+    orderID: string;
+};
+type ConfirmPageParam = CommonPageParam & {
+    kind: "confirm";
+    token: string;
+};
+type SignupPageParam = CommonPageParam & {
+    kind: "signup";
+};
+type SigninPageParam = CommonPageParam & {
+    kind: "signin";
+};
+type ResetPasswordPageParam = CommonPageParam & {
+    kind: "reset_password";
+};
+type ProfilePageParam = CommonPageParam & {
+    kind: "profile";
+};
+type PaymentMethodsPageParam = CommonPageParam & {
+    kind: "payment_methods";
+};
+type AddressesPageParam = CommonPageParam & {
+    kind: "addresses";
+};
+type FavoritesPageParam = CommonPageParam & {
+    kind: "favorites";
+};
+type OrdersPageParam = CommonPageParam & {
+    kind: "orders";
+};
+type SubscriptionsPageParam = CommonPageParam & {
+    kind: "subscriptions";
+};
+type ReturnsPageParam = CommonPageParam & {
+    kind: "returns";
+};
+type StoreCreditPageParam = CommonPageParam & {
+    kind: "store_credit";
+};
+export type PageParam = SignupPageParam | SigninPageParam | ResetPasswordPageParam | ProfilePageParam | PaymentMethodsPageParam | AddressesPageParam | FavoritesPageParam | OrdersPageParam | SubscriptionsPageParam | ReturnsPageParam | StoreCreditPageParam | ConfirmPageParam | CreateReturnPageParam | OrderPageParam | SubscriptionPageParam | ReturnPageParam;
+export declare function isSamePageParam(a: PageParam, b: PageParam): boolean;
+export type ParamExt<P> = {
+    param: P;
+    previousPageKind: PageParam["kind"] | null;
+};
+export interface CreateReturnItemMutable {
+    selected: boolean;
+    quantity: number;
+    reason: ReturnReasonType | null;
+}
+export interface CreateReturnItem extends CreateReturnItemMutable {
+    readonly maxQuantity: number;
+}
+export interface OAuth2Request {
+    kind: CustomerOAuthProviderKind;
+    randomToken: string;
+}
+export type OAuth2Response = {
+    kind: "success";
+    code: string;
+} | {
+    kind: "success_oauth1";
+    token: string;
+    verifier: string;
+} | {
+    kind: "failure";
+};
+export interface CustomerConfig {
+    /** Your shop id. */
+    readonly shopID: string;
+    /** Stripe library instance */
+    readonly stripePromise?: Promise<Stripe | null>;
+    /** These graphql options are applied to all "request" api calls customer profile module does. */
+    readonly opts?: Readonly<GraphQLOpts<any>>;
+    /** A store that represents current auth state. You should pass it in to keep auth state in-sync. */
+    readonly jwt: Store<string>;
+    /** Current locale. Module will react to its changes. */
+    readonly locale: Store<string>;
+    /** Currently set global currency. Module might react to its changes if it's provided. */
+    readonly currency?: Store<string>;
+    /** Shop's default currency. */
+    readonly shopCurrency: string;
+    /** A list of currently available customer oauth2 providers and a request hook */
+    readonly oauth2?: {
+        readonly request: (request: OAuth2Request) => [Promise<OAuth2Response>, () => void];
+        readonly providers: CustomerOAuthProviderKind[];
+    };
+    /**
+     * Persist data across multiple browser tabs (good for multi-page applications).
+     * Note that this only applies to "customerInfo" store. Profile pages state is not a part of it.
+     */
+    readonly persist?: {
+        /** Load data from persistent storage. */
+        readonly load: () => string;
+        /** Save data to persistent storage. */
+        readonly save: (data: string) => void;
+        /**
+         * Register a callback that is called when data is changed in persistent storage (only from the outside,
+         * should ignore "save" calls).
+         */
+        readonly onChange: (callback: (data: string) => void) => void;
+        /** If stored data is older than this, it's ignored. In milliseconds. Default: 30 minutes. */
+        readonly maxAgeMs?: number;
+    };
+}
+export type CustomerInit = {
+    kind: "goto";
+    dest: PageParam;
+} | {
+    kind: "idle";
+} | {
+    kind: "default";
+};
+export declare function createCustomer(config: CustomerConfig, init: CustomerInit): {
+    message: Event<MessageType>;
+    logout: Event<void>;
+    currentPage: Store<PageParam | null>;
+    customerLoggedIn: Store<boolean | null>;
+    customerInfo: Store<CustomerInfo | null>;
+    goTo: Event<PageParam>;
+    unexpectedError: Event<RequestResponseError>;
+    reloadPage: Event<void>;
+    pages: {
+        signin: {
+            init: {
+                event: Event<null>;
+                load: Event<ParamExt<SigninPageParam>>;
+                loaded: Event<SigninPageParam>;
+                pending: Store<boolean>;
+            };
+            form: {
+                init: Event<Partial<{
+                    email: string;
+                    password: string;
+                }>>;
+                reset: Event<void>;
+                submit: Event<void>;
+                submitted: Event<{
+                    email: string;
+                    password: string;
+                }>;
+                valid: Store<boolean>;
+                propagateErrors: Event<Dict<InvalidInputField>>;
+                propagateInitialValues: Event<Partial<{
+                    email: string;
+                    password: string;
+                }>>;
+                errorPropagationFailed: Event<void>;
+            } & {
+                email: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
+                password: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+            } & import("../effector/form.js").CustomFormError<"unauthorized" | "unauthorized_oauth" | null>;
+            formOTPInit: {
+                init: Event<Partial<{
+                    email: string;
+                }>>;
+                reset: Event<void>;
+                submit: Event<void>;
+                submitted: Event<{
+                    email: string;
+                }>;
+                valid: Store<boolean>;
+                propagateErrors: Event<Dict<InvalidInputField>>;
+                propagateInitialValues: Event<Partial<{
+                    email: string;
+                }>>;
+                errorPropagationFailed: Event<void>;
+            } & {
+                email: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
+            } & import("../effector/form.js").CustomFormError<"try_again_later" | null>;
+            formOTPComplete: {
+                init: Event<Partial<{
+                    code: string;
+                }>>;
+                reset: Event<void>;
+                submit: Event<void>;
+                submitted: Event<{
+                    code: string;
+                }>;
+                valid: Store<boolean>;
+                propagateErrors: Event<Dict<InvalidInputField>>;
+                propagateInitialValues: Event<Partial<{
+                    code: string;
+                }>>;
+                errorPropagationFailed: Event<void>;
+            } & {
+                code: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+            } & import("../effector/form.js").CustomFormError<"unauthorized" | null>;
+            signInMode: Store<"email-otp-init" | "email-otp-complete" | "email-password">;
+            setSignInMode: Event<"email-otp-init" | "email-otp-complete" | "email-password">;
+            oauth2Click: Event<CustomerOAuthProviderKind>;
+            somethingIsPending: Store<boolean>;
+        };
+        signup: {
+            init: {
+                event: Event<null>;
+                load: Event<ParamExt<SignupPageParam>>;
+                loaded: Event<SignupPageParam>;
+                pending: Store<boolean>;
+            };
+            form: import("../effector/form.js").Form<{
+                name: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+                email: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
+                password: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+                accepts_marketing: import("../effector/form.js").BooleanField;
+            }>;
+            somethingIsPending: Store<boolean>;
+        };
+        resetPassword: {
+            init: {
+                event: Event<null>;
+                load: Event<ParamExt<ResetPasswordPageParam>>;
+                loaded: Event<ResetPasswordPageParam>;
+                pending: Store<boolean>;
+            };
+            currentStep: Store<{
+                kind: "step1";
+                form: {
+                    init: Event<Partial<{
+                        email: string;
+                    }>>;
+                    reset: Event<void>;
+                    submit: Event<void>;
+                    submitted: Event<{
+                        email: string;
+                    }>;
+                    valid: Store<boolean>;
+                    propagateErrors: Event<Dict<InvalidInputField>>;
+                    propagateInitialValues: Event<Partial<{
+                        email: string;
+                    }>>;
+                    errorPropagationFailed: Event<void>;
+                } & {
+                    email: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
+                } & import("../effector/form.js").CustomFormError<"try_again_later" | null>;
+            } | {
+                kind: "step2";
+                form: {
+                    init: Event<Partial<{
+                        code: string;
+                    }>>;
+                    reset: Event<void>;
+                    submit: Event<void>;
+                    submitted: Event<{
+                        code: string;
+                    }>;
+                    valid: Store<boolean>;
+                    propagateErrors: Event<Dict<InvalidInputField>>;
+                    propagateInitialValues: Event<Partial<{
+                        code: string;
+                    }>>;
+                    errorPropagationFailed: Event<void>;
+                } & {
+                    code: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+                } & import("../effector/form.js").CustomFormError<"not_found" | null>;
+            } | {
+                kind: "step3";
+                form: import("../effector/form.js").Form<{
+                    password: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+                }>;
+            }>;
+            somethingIsPending: Store<boolean>;
+        };
+        addresses: {
+            init: {
+                event: Event<{
+                    availableCountries: ListItem[];
+                    customer: CustomerFragment;
+                    geoCountryCode: string;
+                    geoProvinceCode: string;
+                }>;
+                load: Event<ParamExt<AddressesPageParam>>;
+                loaded: Event<AddressesPageParam>;
+                pending: Store<boolean>;
+            };
+            form: import("../effector/form.js").Form<{
+                id: import("../effector/form.js").StringField<[], string>;
+                name: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+                address1: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+                address2: import("../effector/form.js").StringField<[Validator<"max_length_exceeded">], string>;
+                city: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+                zip: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+                country: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+                province: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+                default_shipping: import("../effector/form.js").BooleanField;
+                default_billing: import("../effector/form.js").BooleanField;
+            }>;
+            showFormFor: Event<number>;
+            toggleFormVisibility: Event<void>;
+            isFormVisible: Store<boolean>;
+            addressEditIndex: Store<number>;
+            pageData: Store<{
+                availableCountries: ListItem[];
+                customer: CustomerFragment;
+                geoCountryCode: string;
+                geoProvinceCode: string;
+            } | null>;
+            availableProvinces: Store<ListItem[]>;
+            deleteAddress: Event<number>;
+            makeDefault: Event<number>;
+            somethingIsPending: Store<boolean>;
+        };
+        favorites: {
+            init: {
+                event: Event<{
+                    favorites: CustomerFavoriteFragment[];
+                }>;
+                load: Event<ParamExt<FavoritesPageParam>>;
+                loaded: Event<FavoritesPageParam>;
+                pending: Store<boolean>;
+            };
+            favorites: Store<CustomerFavoriteFragment[]>;
+            addFavorite: Event<string>;
+            addFavoriteEx: Event<StorefrontCustomerFavoriteCreate>;
+            modifyFavorite: Event<[string, StorefrontCustomerFavoriteModify]>;
+            deleteFavorite: Event<string>;
+            somethingIsPending: Store<boolean>;
+        };
+        orders: {
+            init: {
+                event: Event<{
+                    orders: CustomerOrderBriefFragment[];
+                    lastKey: string;
+                }>;
+                load: Event<ParamExt<OrdersPageParam>>;
+                loaded: Event<OrdersPageParam>;
+                pending: Store<boolean>;
+            };
+            orders: Store<CustomerOrderBriefFragment[]>;
+            loadMore: Event<void>;
+            somethingIsPending: Store<boolean>;
+        };
+        subscriptions: {
+            init: {
+                event: Event<{
+                    subscriptions: CustomerSubscriptionBriefFragment[];
+                    lastKey: string;
+                }>;
+                load: Event<ParamExt<SubscriptionsPageParam>>;
+                loaded: Event<SubscriptionsPageParam>;
+                pending: Store<boolean>;
+            };
+            subscriptions: Store<CustomerSubscriptionBriefFragment[]>;
+            loadMore: Event<void>;
+            somethingIsPending: Store<boolean>;
+        };
+        returns: {
+            init: {
+                event: Event<{
+                    returns: CustomerReturnBriefFragment[];
+                    lastKey: string;
+                }>;
+                load: Event<ParamExt<ReturnsPageParam>>;
+                loaded: Event<ReturnsPageParam>;
+                pending: Store<boolean>;
+            };
+            returns: Store<CustomerReturnBriefFragment[]>;
+            loadMore: Event<void>;
+            somethingIsPending: Store<boolean>;
+        };
+        order: {
+            init: {
+                event: Event<{
+                    order: CustomerOrderFullFragment;
+                }>;
+                load: Event<ParamExt<OrderPageParam>>;
+                loaded: Event<OrderPageParam>;
+                pending: Store<boolean>;
+            };
+            order: Store<CustomerOrderFullFragment | null>;
+            cancelOrder: Event<void>;
+            canCancelOrder: Store<boolean>;
+            somethingIsPending: Store<boolean>;
+        };
+        subscription: {
+            init: {
+                event: Event<{
+                    customer: CustomerFragment;
+                    paymentMethods: CustomerPaymentSourceFragment[];
+                    subscription: CustomerSubscriptionFullFragment;
+                }>;
+                load: Event<ParamExt<SubscriptionPageParam>>;
+                loaded: Event<SubscriptionPageParam>;
+                pending: Store<boolean>;
+            };
+            form: import("../effector/form.js").Form<{
+                billing_address: import("../effector/form.js").StringField<[], SubscriptionParam>;
+                billing_address_id: import("../effector/form.js").StringField<[], string>;
+                shipping_address: import("../effector/form.js").StringField<[], SubscriptionParam>;
+                shipping_address_id: import("../effector/form.js").StringField<[], string>;
+                payment_source: import("../effector/form.js").StringField<[], SubscriptionParam>;
+                payment_source_id: import("../effector/form.js").StringField<[], string>;
+            }>;
+            subscription: Store<CustomerSubscriptionFullFragment | null>;
+            customer: Store<CustomerFragment | null>;
+            paymentMethods: Store<CustomerPaymentSourceFragment[]>;
+            cancel: Event<void>;
+            pause: Event<void>;
+            resume: Event<void>;
+            skipNext: Event<void>;
+            somethingIsPending: Store<boolean>;
+            setBillingAddressValueAndID: Event<[SubscriptionParam, string]>;
+            setShippingAddressValueAndID: Event<[SubscriptionParam, string]>;
+            setPaymentSourceValueAndID: Event<[SubscriptionParam, string]>;
+        };
+        return: {
+            init: {
+                event: Event<{
+                    reasons: ReturnReasonFragment[];
+                    ret: CustomerReturnFullFragment;
+                }>;
+                load: Event<ParamExt<ReturnPageParam>>;
+                loaded: Event<ReturnPageParam>;
+                pending: Store<boolean>;
+            };
+            data: Store<{
+                ret: CustomerReturnFullFragment;
+                reasons: ReturnReasonFragment[];
+            } | null>;
+            somethingIsPending: Store<boolean>;
+        };
+        createReturn: {
+            init: {
+                event: Event<{
+                    fulfillments: CustomerOrderFulfillmentFragment[];
+                    order: CustomerOrderFullFragment;
+                    policy: CustomerReturnPolicyFragment | null;
+                    reasons: ReturnReasonFragment[];
+                }>;
+                load: Event<ParamExt<CreateReturnPageParam>>;
+                loaded: Event<CreateReturnPageParam>;
+                pending: Store<boolean>;
+            };
+            ret: Store<CustomerReturnBriefFragment | null>;
+            info: Store<{
+                fulfillments: CustomerOrderFulfillmentFragment[];
+                order: CustomerOrderFullFragment;
+                policy: CustomerReturnPolicyFragment | null;
+                reasons: ReturnReasonFragment[];
+            } | null>;
+            items: Store<CreateReturnItem[][]>;
+            updateItem: Event<[number, number, Partial<CreateReturnItemMutable>]>;
+            setRefundToCustomerBalance: Event<boolean>;
+            refundToCustomerBalance: Store<boolean>;
+            setShippingOptionIndex: Event<number>;
+            shippingOptionIndex: Store<number>;
+            submit: Event<void>;
+            canSubmit: Store<boolean>;
+            somethingIsPending: Store<boolean>;
+        };
+        storeCredit: {
+            customerBalance: Store<CustomerBalanceFragment | null>;
+            somethingIsPending: Store<boolean>;
+            redeemedGiftCard: Event<void>;
+            setCurrency: Event<string>;
+            currency: Store<string>;
+            loadMore: Event<void>;
+            historyCurrency: Store<string>;
+            history: Store<CustomerBalanceHistoryFragment[]>;
+            toggleFormVisibility: Event<void>;
+            isFormVisible: Store<boolean>;
+            init: {
+                event: Event<{
+                    customerBalance: CustomerBalanceFragment;
+                    history: {
+                        items: CustomerBalanceHistoryFragment[];
+                        last_key: string;
+                    };
+                    currency: string;
+                    resetSuccess: boolean;
+                }>;
+                load: Event<ParamExt<StoreCreditPageParam>>;
+                loaded: Event<StoreCreditPageParam>;
+                pending: Store<boolean>;
+            };
+            form: {
+                init: Event<Partial<{
+                    gift_card_code: string;
+                }>>;
+                reset: Event<void>;
+                submit: Event<void>;
+                submitted: Event<{
+                    gift_card_code: string;
+                }>;
+                valid: Store<boolean>;
+                propagateErrors: Event<Dict<InvalidInputField>>;
+                propagateInitialValues: Event<Partial<{
+                    gift_card_code: string;
+                }>>;
+                errorPropagationFailed: Event<void>;
+            } & {
+                gift_card_code: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">], string>;
+            } & import("../effector/form.js").CustomFormError<"not_found" | null>;
+        };
+        profile: {
+            init: {
+                event: Event<{
+                    customer: CustomerFragment;
+                }>;
+                load: Event<ParamExt<ProfilePageParam>>;
+                loaded: Event<ProfilePageParam>;
+                pending: Store<boolean>;
+            };
+            form: import("../effector/form.js").Form<{
+                name: import("../effector/form.js").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
+                display_name: import("../effector/form.js").StringField<[Validator<"max_length_exceeded">], string>;
+                mobile: import("../effector/form.js").StringField<[], string>;
+                mobile_notifications: import("../effector/form.js").BooleanField;
+                accepts_marketing: import("../effector/form.js").BooleanField;
+            }>;
+            somethingIsPending: Store<boolean>;
+        };
+        paymentMethods: {
+            pageData: Store<{
+                availableCountries: ListItem[];
+                customer: CustomerFragment;
+                paymentMethods: CustomerPaymentSourceFragment[];
+                geoip: IPAndUAInfoFragment;
+            } | null>;
+            availableProvinces: Store<ListItem[]>;
+            somethingIsPending: Store<boolean>;
+            setStripeElement: Event<StripeCardElement | StripeCardNumberElement | null>;
+            stripeNumber: {
+                setAPIError: Event<StripeNumberError | null>;
+                setInvalid: Event<"unknown" | StripeNumberError | null>;
+                setComplete: Event<boolean>;
+                touched: Store<boolean>;
+                complete: Store<boolean>;
+                invalid: Store<"unknown" | StripeNumberError | null>;
+                apiError: Store<StripeNumberError | null>;
+                error: Store<"unknown" | "incomplete" | NonNullable<StripeNumberError> | null>;
+            };
+            stripeExpiry: {
+                setAPIError: Event<StripeExpiryError | null>;
+                setInvalid: Event<"unknown" | StripeExpiryError | null>;
+                setComplete: Event<boolean>;
+                touched: Store<boolean>;
+                complete: Store<boolean>;
+                invalid: Store<"unknown" | StripeExpiryError | null>;
+                apiError: Store<StripeExpiryError | null>;
+                error: Store<"unknown" | "incomplete" | NonNullable<StripeExpiryError> | null>;
+            };
+            stripeCVC: {
+                setAPIError: Event<StripeCVCError | null>;
+                setInvalid: Event<"unknown" | StripeCVCError | null>;
+                setComplete: Event<boolean>;
+                touched: Store<boolean>;
+                complete: Store<boolean>;
+                invalid: Store<"unknown" | StripeCVCError | null>;
+                apiError: Store<StripeCVCError | null>;
+                error: Store<"unknown" | "incomplete" | NonNullable<StripeCVCError> | null>;
+            };
+            deletePaymentMethod: Event<string>;
+            toggleFormVisibility: Event<void>;
+            isFormVisible: Store<boolean>;
+            init: {
+                event: Event<{
+                    availableCountries: ListItem[];
+                    customer: CustomerFragment;
+                    paymentMethods: CustomerPaymentSourceFragment[];
+                    geoip: IPAndUAInfoFragment;
+                }>;
+                load: Event<ParamExt<PaymentMethodsPageParam>>;
+                loaded: Event<PaymentMethodsPageParam>;
+                pending: Store<boolean>;
+            };
+            form: import("../effector/form.js").Form<{
+                name: import("../effector/form.js").StringField<[], string>;
+                address: import("../effector/form.js").StringField<[], string>;
+                city: import("../effector/form.js").StringField<[], string>;
+                zip: import("../effector/form.js").StringField<[], string>;
+                country: import("../effector/form.js").StringField<[], string>;
+                province: import("../effector/form.js").StringField<[], string>;
+                as_default: import("../effector/form.js").BooleanField;
+            }>;
+        };
+    };
+    somethingPending: Store<boolean>;
+    oauth2: {
+        cancel: Event<void>;
+        pending: Store<boolean>;
+        providers: Store<CustomerOAuthProviderKind[]>;
+        connect: Event<CustomerOAuthProviderKind>;
+        disconnect: Event<void>;
+    };
+};
+export type Customer = ReturnType<typeof createCustomer>;
+export {};

package/types/modules/helpers/cartInitOption.d.ts

@@ -0,0 +1,2 @@
+import type { CartInit } from "../cart.js";
+export declare function cartInitOption(token: string | undefined, id: string | undefined, uuid: string | undefined): CartInit;

package/types/modules/helpers/cookieConsent.d.ts

@@ -0,0 +1,4 @@
+export declare function createCookieConsent(key: string): {
+    setCookieConsentClicked: import("effector").Event<boolean>;
+    cookieConsentClicked: import("effector").Store<boolean>;
+};

package/types/modules/helpers/customerOauth2.d.ts

@@ -0,0 +1,19 @@
+import type { CustomerOAuthProviderKind } from "../../graphql/types.js";
+import { GraphQLOpts } from "../../request.js";
+import type { ShopLike } from "../../shopDomain.js";
+interface OAuthProviderInfo {
+    url: string;
+    scope: string;
+}
+export declare const oauthProviders: Record<CustomerOAuthProviderKind, OAuthProviderInfo>;
+export interface GetProviderURLArgs {
+    kind: CustomerOAuthProviderKind;
+    shopID: string;
+    shop: ShopLike | string;
+    clientID: string;
+    randomToken: string;
+    opts?: GraphQLOpts<any>;
+}
+export declare function getProviderURL(a: GetProviderURLArgs): Promise<string>;
+export declare function launchAndFocusProviderPopupWindow(a: GetProviderURLArgs): Promise<void>;
+export {};

package/types/modules/helpers/getOAuth2Hook.d.ts

@@ -0,0 +1,22 @@
+import type Postmate from "postmate";
+import type { CustomerOAuthProviderFragment } from "../../graphql/types.js";
+import type { GraphQLOpts } from "../../request.js";
+import type { OAuth2Request, OAuth2Response } from "../customer.js";
+export type PopupConnectResult = {
+    kind: "success";
+    code: string;
+} | {
+    kind: "success_oauth1";
+    token: string;
+    verifier: string;
+} | {
+    kind: "failure";
+};
+export interface GetOAuth2HookArgs {
+    remote: Postmate;
+    oauth2Providers: CustomerOAuthProviderFragment[];
+    shopDomain: string;
+    shopID: string;
+    opts: GraphQLOpts<any>;
+}
+export declare function getOAuth2Hook(args: GetOAuth2HookArgs): (req: OAuth2Request) => [Promise<OAuth2Response>, () => void];