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

Medusa-first storefront data layer built on TanStack Query.

import type { HttpTypes } from "@medusajs/types";
import type { MedusaCompleteCartResult } from "../cart/medusa-service";
import type { AddLineItemInputBase, CartInputBase, CartQueryKeys, RemoveLineItemInputBase, UpdateLineItemInputBase, UseCartResult, UseSuspenseCartResult } from "../cart/types";
import { type ActiveCartQueryKeyMatcher } from "../shared/cart-cache-sync";
import type { ReadQueryOptions, SuspenseQueryOptions } from "../shared/hook-types";
import type { StorageValueStore } from "../shared/storage-value-store";
type MedusaCartMutationHook<TInput> = (options?: {
    onSuccess?: (cart: HttpTypes.StoreCart) => void | Promise<void>;
    onError?: (error: unknown) => void;
}) => {
    mutate: (input: TInput, options?: {
        onSuccess?: (cart: HttpTypes.StoreCart) => void;
        onError?: (error: MedusaCartMutationError) => void;
    }) => void;
    mutateAsync: (input: TInput) => Promise<HttpTypes.StoreCart>;
    isPending: boolean;
};
type MedusaCompleteCartHook = (options?: {
    onMutate?: (variables: {
        cartId?: string;
    }) => unknown;
    onSuccess?: (result: MedusaCompleteCartResult, variables: {
        cartId?: string;
    }, context: unknown) => void;
    onError?: (error: unknown) => void;
}) => {
    mutateAsync: (input: {
        cartId?: string;
    }) => Promise<MedusaCompleteCartResult>;
    isPending: boolean;
};
export type MedusaCartFlowStorefront = {
    hooks: {
        cart: {
            useCart: (input: CartInputBase, options?: {
                queryOptions?: ReadQueryOptions<HttpTypes.StoreCart | null>;
            }) => UseCartResult<HttpTypes.StoreCart>;
            useSuspenseCart: (input: CartInputBase, options?: {
                queryOptions?: SuspenseQueryOptions<HttpTypes.StoreCart | null>;
            }) => UseSuspenseCartResult<HttpTypes.StoreCart>;
            useAddLineItem: MedusaCartMutationHook<AddLineItemInputBase>;
            useUpdateLineItem: MedusaCartMutationHook<UpdateLineItemInputBase>;
            useRemoveLineItem: MedusaCartMutationHook<RemoveLineItemInputBase>;
            useCompleteCart: MedusaCompleteCartHook;
        };
    };
    queryKeys: {
        cart: CartQueryKeys;
        checkout: {
            all: () => readonly unknown[];
            shippingOptions: (cartId: string) => readonly unknown[];
            paymentProviders: (regionId: string) => readonly unknown[];
        };
        orders: {
            all: () => readonly unknown[];
            detail: (params: {
                id: string;
            }) => readonly unknown[];
        };
    };
    services: {
        cart: {
            retrieveCart: (cartId: string, signal?: AbortSignal) => Promise<HttpTypes.StoreCart | null>;
        };
    };
};
export type MedusaCartMutationError = {
    message: string;
    code?: string;
};
export type MedusaCompleteCartFlowError = {
    message: string;
    type: string;
    name?: string;
};
export type UseMedusaCartReturn = {
    cart: HttpTypes.StoreCart | null;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    itemCount: number;
    isEmpty: boolean;
    hasItems: boolean;
};
export type UseMedusaSuspenseCartReturn = {
    cart: HttpTypes.StoreCart | null;
    itemCount: number;
    isEmpty: boolean;
    hasItems: boolean;
};
export type UseMedusaCartMutationOptions = {
    onSuccess?: (cart: HttpTypes.StoreCart) => void;
    onError?: (error: MedusaCartMutationError) => void;
};
export type UseMedusaCompleteCartOptions = {
    onSuccess?: (order: HttpTypes.StoreOrder) => void;
    onError?: (error: MedusaCompleteCartFlowError, cart: HttpTypes.StoreCart) => void;
    onRequestError?: (error: unknown) => void;
};
export type CreateMedusaCartFlowConfig = {
    storefront: MedusaCartFlowStorefront;
    cartStorage?: StorageValueStore;
    isActiveCartQueryKey?: ActiveCartQueryKeyMatcher;
};
export type UseMedusaCartInput = Omit<CartInputBase, "cartId"> & {
    cartId?: string;
};
export declare function createMedusaCartFlow({ storefront, cartStorage, isActiveCartQueryKey: customActiveCartQueryKeyMatcher, }: CreateMedusaCartFlowConfig): {
    useCart: (input?: UseMedusaCartInput) => UseMedusaCartReturn;
    useSuspenseCart: (input?: UseMedusaCartInput) => UseMedusaSuspenseCartReturn;
    useAddToCart: (options?: UseMedusaCartMutationOptions) => {
        mutate: (input: AddLineItemInputBase, mutateOptions?: {
            onSuccess?: ((cart: HttpTypes.StoreCart) => void) | undefined;
            onError?: ((error: MedusaCartMutationError) => void) | undefined;
        } | undefined) => void;
        mutateAsync: (input: AddLineItemInputBase) => Promise<HttpTypes.StoreCart>;
        isPending: boolean;
    };
    useUpdateLineItem: (options?: UseMedusaCartMutationOptions) => {
        mutate: (input: UpdateLineItemInputBase, mutateOptions?: {
            onSuccess?: ((cart: HttpTypes.StoreCart) => void) | undefined;
            onError?: ((error: MedusaCartMutationError) => void) | undefined;
        } | undefined) => void;
        mutateAsync: (input: UpdateLineItemInputBase) => Promise<HttpTypes.StoreCart>;
        isPending: boolean;
    };
    useRemoveLineItem: (options?: UseMedusaCartMutationOptions) => {
        mutate: (input: RemoveLineItemInputBase, mutateOptions?: {
            onSuccess?: ((cart: HttpTypes.StoreCart) => void) | undefined;
            onError?: ((error: MedusaCartMutationError) => void) | undefined;
        } | undefined) => void;
        mutateAsync: (input: RemoveLineItemInputBase) => Promise<HttpTypes.StoreCart>;
        isPending: boolean;
    };
    useCompleteCart: (options?: UseMedusaCompleteCartOptions) => {
        mutateAsync: (input: {
            cartId?: string;
        }) => Promise<MedusaCompleteCartResult>;
        isPending: boolean;
    };
};
export {};
//# sourceMappingURL=cart-flow.d.ts.map