@techsio/storefront-data/dist/medusa/checkout-flow.d.ts

Medusa-first storefront data layer built on TanStack Query.

import type { HttpTypes } from "@medusajs/types";
import type { QueryClient } from "@tanstack/react-query";
import { type ActiveCartQueryKeyMatcher } from "../shared/cart-cache-sync";
import type { StorageValueStore } from "../shared/storage-value-store";
import { type MedusaCartFlowStorefront } from "./cart-flow";
type MedusaCheckoutShippingHook = (input: {
    cartId?: string;
    cart?: HttpTypes.StoreCart | null;
    enabled?: boolean;
    calculatePrices?: boolean;
}, options?: {
    onSuccess?: (cart: HttpTypes.StoreCart) => void;
    onError?: (error: unknown) => void;
}) => {
    shippingOptions: HttpTypes.StoreCartShippingOption[];
    shippingPrices: Record<string, number>;
    isLoading: boolean;
    isFetching: boolean;
    isCalculating: boolean;
    setShippingMethod: (optionId: string, data?: Record<string, unknown>) => void;
    isSettingShipping: boolean;
    selectedShippingMethodId?: string;
    selectedShippingMethodData?: Record<string, unknown>;
    selectedOption?: HttpTypes.StoreCartShippingOption;
};
type MedusaCheckoutPaymentHook = (input: {
    cartId?: string;
    regionId?: string;
    cart?: HttpTypes.StoreCart | null;
    enabled?: boolean;
}, options?: {
    onSuccess?: (paymentCollection: HttpTypes.StorePaymentCollection) => void;
    onError?: (error: unknown) => void;
}) => {
    paymentProviders: HttpTypes.StorePaymentProvider[];
    initiatePayment: (providerId: string) => void;
    initiatePaymentAsync: (providerId: string) => Promise<HttpTypes.StorePaymentCollection>;
    isInitiatingPayment: boolean;
    isLoading: boolean;
    isFetching: boolean;
    canInitiatePayment: boolean;
    hasPaymentCollection: boolean;
    hasPaymentSessions: boolean;
};
export type MedusaCheckoutFlowStorefront = MedusaCartFlowStorefront & {
    hooks: MedusaCartFlowStorefront["hooks"] & {
        checkout: {
            useCheckoutShipping: MedusaCheckoutShippingHook;
            useCheckoutPayment: MedusaCheckoutPaymentHook;
            fetchPaymentProviders: (queryClient: QueryClient, regionId: string) => Promise<HttpTypes.StorePaymentProvider[]>;
        };
    };
};
export type MedusaShippingMethodData = Record<string, unknown>;
export type UseMedusaCheckoutShippingOptions = {
    enabled?: boolean;
    calculatePrices?: boolean;
    onSuccess?: (cart: HttpTypes.StoreCart) => void;
    onError?: (error: unknown) => void;
    normalizeShippingData?: (data?: MedusaShippingMethodData) => Record<string, unknown> | undefined;
};
export type UseMedusaCheckoutShippingReturn = {
    shippingOptions: HttpTypes.StoreCartShippingOption[];
    shippingPrices: Record<string, number>;
    isLoading: boolean;
    isFetching: boolean;
    isCalculating: boolean;
    setShipping: (optionId: string, data?: MedusaShippingMethodData) => void;
    isSettingShipping: boolean;
    canLoadShipping: boolean;
    canSetShipping: boolean;
    selectedShippingMethodId?: string;
    selectedOption?: HttpTypes.StoreCartShippingOption;
};
export type UseMedusaCheckoutPaymentOptions = {
    enabled?: boolean;
    onSuccess?: (paymentCollection: HttpTypes.StorePaymentCollection) => void;
    onError?: (error: unknown) => void;
};
export type UseMedusaCheckoutPaymentReturn = {
    paymentProviders: HttpTypes.StorePaymentProvider[];
    initiatePayment: (providerId: string) => void;
    initiatePaymentAsync: (providerId: string) => Promise<HttpTypes.StorePaymentCollection>;
    isInitiatingPayment: boolean;
    isLoading: boolean;
    isFetching: boolean;
    canInitiatePayment: boolean;
    hasPaymentCollection: boolean;
    hasPaymentSessions: boolean;
};
export type CreateMedusaCheckoutFlowConfig = {
    storefront: MedusaCheckoutFlowStorefront;
    cartStorage?: StorageValueStore;
    isActiveCartQueryKey?: ActiveCartQueryKeyMatcher;
};
export type UseMedusaCompleteCheckoutInput = {
    cartId?: string;
    cart?: HttpTypes.StoreCart | null;
    regionId?: string;
    enabled?: boolean;
};
export type MedusaCompleteCheckoutRequest = {
    paymentProviderId?: string;
};
export type MedusaCompleteCheckoutStage = "cart" | "payment_provider" | "payment" | "complete";
export type MedusaCompleteCheckoutError = {
    stage: MedusaCompleteCheckoutStage;
    message: string;
    cause?: unknown;
};
export type MedusaCompleteCheckoutSuccess = {
    order: HttpTypes.StoreOrder;
    paymentCollection: HttpTypes.StorePaymentCollection;
    paymentProviderId: string;
};
export type ResolvePaymentProviderContext = {
    cart?: HttpTypes.StoreCart | null;
    existingPaymentProviderId?: string;
    paymentProviders: HttpTypes.StorePaymentProvider[];
    requestedPaymentProviderId?: string;
};
export type UseMedusaCompleteCheckoutOptions = {
    resolvePaymentProviderId?: (context: ResolvePaymentProviderContext) => string | null | undefined;
    onSuccess?: (result: MedusaCompleteCheckoutSuccess) => void;
    onError?: (error: MedusaCompleteCheckoutError) => void;
};
export declare function createMedusaCheckoutFlow({ storefront, cartStorage, isActiveCartQueryKey, }: CreateMedusaCheckoutFlowConfig): {
    useCheckoutShipping: (cartId?: string, cart?: HttpTypes.StoreCart | null, options?: UseMedusaCheckoutShippingOptions) => UseMedusaCheckoutShippingReturn;
    useCheckoutPayment: (cartId?: string, regionId?: string, cart?: HttpTypes.StoreCart | null, options?: UseMedusaCheckoutPaymentOptions) => UseMedusaCheckoutPaymentReturn;
    useCompleteCheckout: (input: UseMedusaCompleteCheckoutInput, options?: UseMedusaCompleteCheckoutOptions) => import("@tanstack/react-query").UseMutationResult<MedusaCompleteCheckoutSuccess, MedusaCompleteCheckoutError, MedusaCompleteCheckoutRequest | undefined, unknown>;
};
export {};
//# sourceMappingURL=checkout-flow.d.ts.map