import { Event, Store } from "effector";
import { Validator } from "../effector/validator";
import { Stripe, StripeCardElement, StripeCardNumberElement } from "@stripe/stripe-js";
import { GraphQLOpts, RequestResponseError } from "../request";
import { CustomerBalanceFragment, CustomerFragment, CustomerOrderBriefFragment, CustomerOrderFullFragment, CustomerPaymentSourceFragment, IPAndUAInfoFragment, CustomerFavoriteFragment, StorefrontCustomerFavoriteModify, CustomerOAuthProviderKind, StorefrontCustomerFavoriteCreate, CustomerBalanceHistoryFragment, CustomerReturnBriefFragment, CustomerReturnFullFragment, ReturnReasonType, CustomerOrderFulfillmentFragment, CustomerReturnPolicyFragment, ReturnReasonFragment, CartVariantFragment, CustomerSubscriptionBriefFragment, CustomerSubscriptionFullFragment, SubscriptionParam } from "../graphql/types";
import { InvalidInputField } from "../mapInvalidInput";
import { Dict, ListItem } from "../commonTypes";
import { StripeCVCError, StripeExpiryError, StripeNumberError } from "../stripeError";
export declare 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>;
declare type CommonPageParam = {
    action: "push" | "pop" | "push_redirect" | "pop_redirect";
};
declare type OrderPageParam = CommonPageParam & {
    kind: "order";
    orderID: string;
};
declare type SubscriptionPageParam = CommonPageParam & {
    kind: "subscription";
    subscriptionID: string;
};
declare type ReturnPageParam = CommonPageParam & {
    kind: "return";
    returnID: string;
};
declare type CreateReturnPageParam = CommonPageParam & {
    kind: "create_return";
    orderID: string;
};
declare type ConfirmPageParam = CommonPageParam & {
    kind: "confirm";
    token: string;
};
declare type SignupPageParam = CommonPageParam & {
    kind: "signup";
};
declare type SigninPageParam = CommonPageParam & {
    kind: "signin";
};
declare type ResetPasswordPageParam = CommonPageParam & {
    kind: "reset_password";
};
declare type ProfilePageParam = CommonPageParam & {
    kind: "profile";
};
declare type PaymentMethodsPageParam = CommonPageParam & {
    kind: "payment_methods";
};
declare type AddressesPageParam = CommonPageParam & {
    kind: "addresses";
};
declare type FavoritesPageParam = CommonPageParam & {
    kind: "favorites";
};
declare type OrdersPageParam = CommonPageParam & {
    kind: "orders";
};
declare type SubscriptionsPageParam = CommonPageParam & {
    kind: "subscriptions";
};
declare type ReturnsPageParam = CommonPageParam & {
    kind: "returns";
};
declare type StoreCreditPageParam = CommonPageParam & {
    kind: "store_credit";
};
export declare 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 declare 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 declare 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[];
    };
}
export declare 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").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
                password: import("../effector/form").StringField<[Validator<"invalid_non_empty">], string>;
            } & import("../effector/form").CustomFormError<"unauthorized" | "unauthorized_oauth" | null>;
            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").Form<{
                name: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
                email: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
                password: import("../effector/form").StringField<[Validator<"invalid_non_empty">], string>;
                accepts_marketing: import("../effector/form").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").StringField<[Validator<"invalid_non_empty">, Validator<"invalid_email">, Validator<"max_length_exceeded">], string>;
                } & import("../effector/form").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").StringField<[Validator<"invalid_non_empty">], string>;
                } & import("../effector/form").CustomFormError<"not_found" | null>;
            } | {
                kind: "step3";
                form: import("../effector/form").Form<{
                    password: import("../effector/form").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").Form<{
                id: import("../effector/form").StringField<[], string>;
                name: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
                address1: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
                address2: import("../effector/form").StringField<[Validator<"max_length_exceeded">], string>;
                city: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
                zip: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
                country: import("../effector/form").StringField<[Validator<"invalid_non_empty">], string>;
                province: import("../effector/form").StringField<[Validator<"invalid_non_empty">], string>;
                default_shipping: import("../effector/form").BooleanField;
                default_billing: import("../effector/form").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").Form<{
                billing_address: import("../effector/form").StringField<[], SubscriptionParam>;
                billing_address_id: import("../effector/form").StringField<[], string>;
                shipping_address: import("../effector/form").StringField<[], SubscriptionParam>;
                shipping_address_id: import("../effector/form").StringField<[], string>;
                payment_source: import("../effector/form").StringField<[], SubscriptionParam>;
                payment_source_id: import("../effector/form").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").StringField<[Validator<"invalid_non_empty">], string>;
            } & import("../effector/form").CustomFormError<"not_found" | null>;
        };
        profile: {
            init: {
                event: Event<{
                    customer: CustomerFragment;
                }>;
                load: Event<ParamExt<ProfilePageParam>>;
                loaded: Event<ProfilePageParam>;
                pending: Store<boolean>;
            };
            form: import("../effector/form").Form<{
                name: import("../effector/form").StringField<[Validator<"invalid_non_empty">, Validator<"max_length_exceeded">], string>;
                display_name: import("../effector/form").StringField<[Validator<"max_length_exceeded">], string>;
                mobile: import("../effector/form").StringField<[], string>;
                mobile_notifications: import("../effector/form").BooleanField;
                accepts_marketing: import("../effector/form").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" | StripeNumberError | "incomplete" | 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" | StripeExpiryError | "incomplete" | 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" | StripeCVCError | "incomplete" | 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").Form<{
                name: import("../effector/form").StringField<[], string>;
                address: import("../effector/form").StringField<[], string>;
                city: import("../effector/form").StringField<[], string>;
                zip: import("../effector/form").StringField<[], string>;
                country: import("../effector/form").StringField<[], string>;
                province: import("../effector/form").StringField<[], string>;
                as_default: import("../effector/form").BooleanField;
            }>;
        };
    };
    somethingPending: Store<boolean>;
    oauth2: {
        cancel: Event<void>;
        pending: Store<boolean>;
        providers: Store<CustomerOAuthProviderKind[]>;
        connect: Event<CustomerOAuthProviderKind>;
        disconnect: Event<void>;
    };
};
export declare type Customer = ReturnType<typeof createCustomer>;
export {};