import '@emotion/react';
import type { SubscriptionManager } from './lib/subscription-manager';
import type { Theme as ThemeType } from './lib/theme';
import type { ReactElement } from 'react';
declare module '@emotion/react' {
    interface Theme extends ThemeType {
    }
}
export interface CheckoutStepProps {
    stepId: string;
    titleContent: React.ReactNode;
    isCompleteCallback: IsCompleteCallback;
    activeStepContent?: React.ReactNode;
    activeStepFooter?: React.ReactNode;
    activeStepHeader?: React.ReactNode;
    completeStepContent?: React.ReactNode;
    className?: string;
    canEditStep?: boolean;
    editButtonText?: string;
    editButtonElement?: React.ReactNode;
    editButtonAriaLabel?: string;
    nextStepButtonText?: string;
    nextStepButtonAriaLabel?: string;
    validatingButtonText?: string;
    validatingButtonAriaLabel?: string;
    skipValidationOnSubmit?: boolean;
    onPageLoadError?: CheckoutPageErrorCallback;
}
export type IsCompleteCallback = () => boolean | Promise<boolean>;
export type StepCompleteCallback = () => Promise<boolean>;
export interface PaymentMethodSubmitButtonProps {
    disabled?: boolean;
    onClick?: ProcessPayment;
}
export interface PaymentMethod {
    id: string;
    paymentProcessorId: string;
    label?: React.ReactNode;
    activeContent?: React.ReactNode;
    inactiveContent?: React.ReactNode;
    submitButton: ReactElement<PaymentMethodSubmitButtonProps>;
    getAriaLabel: (localize: (value: string) => string) => string;
    hasRequiredFields?: boolean;
    isInitiallyDisabled?: boolean;
}
export type ExternalPaymentMethod = Partial<PaymentMethod>;
export interface FormAndTransactionStatus {
    formStatus: FormStatus;
    transactionStatus: TransactionStatusState;
}
export declare enum FormStatus {
    LOADING = "loading",
    READY = "ready",
    SUBMITTING = "submitting",
    VALIDATING = "validating"
}
export interface FormStatusState {
    formStatus: FormStatus;
}
export type FormAndTransactionStatusAction = FormStatusAction | TransactionStatusAction;
export type FormStatusAction = ReactStandardAction<'FORM_STATUS_CHANGE', FormStatus>;
export interface FormStatusController extends FormStatusState {
    setFormReady: () => void;
    setFormLoading: () => void;
    setFormValidating: () => void;
    setFormSubmitting: () => void;
}
export type FormStatusSetter = (newStatus: FormStatus) => void;
export type FormAndTransactionStatusManager = FormStatusManager & TransactionStatusManager;
export type FormStatusManager = {
    formStatus: FormStatus;
    setFormStatus: FormStatusSetter;
};
export interface PaymentMethodProviderContextInterface {
    allPaymentMethods: PaymentMethod[];
    paymentProcessors: PaymentProcessorProp;
    disabledPaymentMethodIds: string[];
    setDisabledPaymentMethodIds: (methods: string[]) => void;
    paymentMethodId: string | null | undefined;
    setPaymentMethodId: (id: string) => void;
    onPaymentMethodChanged?: PaymentMethodChangedCallback;
    loadingPaymentMethodIds: string[];
    setLoadingPaymentMethodIds: (methods: string[]) => void;
}
export type ReactStandardAction<T = string, P = unknown> = P extends void ? {
    type: T;
    payload?: P;
} : {
    type: T;
    payload?: P;
};
export interface CheckoutProviderProps {
    theme?: ThemeType;
    paymentMethods: PaymentMethod[];
    onPaymentComplete?: PaymentEventCallback;
    onPaymentRedirect?: PaymentEventCallback;
    onPaymentError?: PaymentErrorCallback;
    onPageLoadError?: CheckoutPageErrorCallback;
    onStepChanged?: StepChangedCallback;
    onPaymentMethodChanged?: PaymentMethodChangedCallback;
    isLoading?: boolean;
    redirectToUrl?: (url: string) => void;
    paymentProcessors: PaymentProcessorProp;
    isValidating?: boolean;
    initiallySelectedPaymentMethodId?: string | null;
    selectFirstAvailablePaymentMethod?: boolean;
    children: React.ReactNode;
}
export interface PaymentProcessorProp {
    [key: string]: PaymentProcessorFunction;
}
export type StepChangedCallback = (args: StepChangedEventArguments) => void;
export type PaymentMethodChangedCallback = (method: string) => void;
export type PaymentEventCallback = (args: PaymentEventCallbackArguments) => void;
export type PaymentErrorCallback = (args: {
    paymentMethodId: string | null | undefined;
    transactionError: string | null;
}) => void;
export type CheckoutPageErrorCallback = (errorType: string, error: Error, errorData?: Record<string, string | number | undefined>) => void;
export type StepChangedEventArguments = {
    stepNumber: number | null;
    previousStepNumber: number;
    paymentMethodId: string;
};
export type PaymentEventCallbackArguments = {
    transactionLastResponse: PaymentProcessorResponseData;
};
export type PaymentProcessorResponseData = unknown;
export type PaymentProcessorError = {
    type: PaymentProcessorResponseType.ERROR;
    payload: string;
};
export type PaymentProcessorSuccess = {
    type: PaymentProcessorResponseType.SUCCESS;
    payload: PaymentProcessorResponseData;
};
export type PaymentProcessorRedirect = {
    type: PaymentProcessorResponseType.REDIRECT;
    payload: string | undefined;
};
export type PaymentProcessorResponse = PaymentProcessorError | PaymentProcessorSuccess | PaymentProcessorRedirect;
export type PaymentProcessorSubmitData = unknown;
export type PaymentProcessorFunction = (submitData: PaymentProcessorSubmitData) => Promise<PaymentProcessorResponse>;
export declare enum PaymentProcessorResponseType {
    SUCCESS = "SUCCESS",
    REDIRECT = "REDIRECT",
    ERROR = "ERROR"
}
export declare enum TransactionStatus {
    NOT_STARTED = "not-started",
    PENDING = "pending",
    COMPLETE = "complete",
    REDIRECTING = "redirecting",
    ERROR = "error"
}
export interface TransactionStatusState {
    transactionStatus: TransactionStatus;
    previousTransactionStatus: TransactionStatus;
    transactionLastResponse: PaymentProcessorResponseData | null;
    transactionError: string | null;
    transactionRedirectUrl: string | null;
}
export interface TransactionStatusPayloads {
    status: TransactionStatus;
    response?: PaymentProcessorResponseData;
    error?: string;
    url?: string;
}
export interface TransactionStatusPayloadNotStarted extends Pick<TransactionStatusPayloads, 'status'> {
    status: TransactionStatus.NOT_STARTED;
}
export interface TransactionStatusPayloadPending extends Pick<TransactionStatusPayloads, 'status'> {
    status: TransactionStatus.PENDING;
}
export interface TransactionStatusPayloadComplete extends Required<Pick<TransactionStatusPayloads, 'status' | 'response'>> {
    status: TransactionStatus.COMPLETE;
}
export interface TransactionStatusPayloadRedirecting extends Required<Pick<TransactionStatusPayloads, 'status' | 'url'>> {
    status: TransactionStatus.REDIRECTING;
}
export interface TransactionStatusPayloadError extends Required<Pick<TransactionStatusPayloads, 'status' | 'error'>> {
    status: TransactionStatus.ERROR;
}
export type TransactionStatusPayload = TransactionStatusPayloadNotStarted | TransactionStatusPayloadPending | TransactionStatusPayloadComplete | TransactionStatusPayloadRedirecting | TransactionStatusPayloadError;
export type TransactionStatusAction = ReactStandardAction<'TRANSACTION_STATUS_CHANGE', TransactionStatusPayload>;
export interface TransactionStatusManager extends TransactionStatusState {
    resetTransaction: ResetTransaction;
    setTransactionError: SetTransactionError;
    setTransactionComplete: SetTransactionComplete;
    setTransactionPending: SetTransactionPending;
    setTransactionRedirecting: SetTransactionRedirecting;
}
export type ProcessPayment = (processorData: PaymentProcessorSubmitData) => Promise<PaymentProcessorResponse>;
export type SetTransactionRedirecting = (url: string) => void;
export type SetTransactionPending = () => void;
export type SetTransactionComplete = (response: PaymentProcessorResponseData) => void;
export type SetTransactionError = (message: string) => void;
export type ResetTransaction = () => void;
export type StepIdMap = Record<string, number>;
export type StepCompleteCallbackMap = Record<string, StepCompleteCallback>;
export type SetStepComplete = (stepId: string) => Promise<boolean>;
export type CompleteAllSteps = () => Promise<boolean>;
export type MakeStepActive = (stepId: string) => Promise<boolean>;
export type CheckoutStepCompleteStatus = Record<string, boolean>;
export interface CheckoutStepGroupStore {
    state: CheckoutStepGroupState;
    actions: CheckoutStepGroupActions;
    subscription: SubscriptionManager;
}
export interface CheckoutStepGroupState {
    activeStepNumber: number;
    totalSteps: number;
    stepCompleteStatus: CheckoutStepCompleteStatus;
    stepIdMap: StepIdMap;
    stepCompleteCallbackMap: StepCompleteCallbackMap;
    stepSkipValidationOnSubmitMap: Record<number, boolean>;
}
export interface CheckoutStepGroupActions {
    setActiveStepNumber: (stepNumber: number) => void;
    setStepCompleteStatus: (newStatus: CheckoutStepCompleteStatus) => void;
    setStepComplete: SetStepComplete;
    completeAllSteps: CompleteAllSteps;
    makeStepActive: MakeStepActive;
    getStepNumberFromId: (stepId: string) => number | undefined;
    setStepCompleteCallback: (stepNumber: number, stepId: string, callback: StepCompleteCallback, skipValidationOnSubmit?: boolean) => void;
    getStepCompleteCallback: (stepNumber: number) => StepCompleteCallback;
    setTotalSteps: (totalSteps: number) => void;
}
export type TogglePaymentMethod = (paymentMethodId: string, available: boolean) => void;
//# sourceMappingURL=types.d.ts.map