@plasmicpkgs/commerce 0.0.246 → 0.0.248

package/dist/api/endpoints/cart.d.ts

@@ -1,4 +1,4 @@
-import type { CartSchema } from '../../types/cart';
-import type { GetAPISchema } from '..';
-declare const cartEndpoint: GetAPISchema<any, CartSchema<any>>['endpoint']['handler'];
-export default cartEndpoint;
+import type { CartSchema } from '../../types/cart';
+import type { GetAPISchema } from '..';
+declare const cartEndpoint: GetAPISchema<any, CartSchema<any>>['endpoint']['handler'];
+export default cartEndpoint;

package/dist/api/endpoints/catalog/products.d.ts

@@ -1,4 +1,4 @@
-import type { ProductsSchema } from '../../../types/product';
-import type { GetAPISchema } from '../..';
-declare const productsEndpoint: GetAPISchema<any, ProductsSchema>['endpoint']['handler'];
-export default productsEndpoint;
+import type { ProductsSchema } from '../../../types/product';
+import type { GetAPISchema } from '../..';
+declare const productsEndpoint: GetAPISchema<any, ProductsSchema>['endpoint']['handler'];
+export default productsEndpoint;

package/dist/api/index.d.ts

@@ -1,75 +1,75 @@
-import type { NextApiHandler } from 'next';
-import type { FetchOptions, Response } from '@vercel/fetch';
-import type { APIEndpoint, APIHandler } from './utils/types';
-import type { CartSchema } from '../types/cart';
-import type { CustomerSchema } from '../types/customer';
-import type { LoginSchema } from '../types/login';
-import type { LogoutSchema } from '../types/logout';
-import type { SignupSchema } from '../types/signup';
-import type { ProductsSchema } from '../types/product';
-import type { WishlistSchema } from '../types/wishlist';
-import type { CheckoutSchema } from '../types/checkout';
-import type { CustomerCardSchema } from '../types/customer/card';
-import type { CustomerAddressSchema } from '../types/customer/address';
-import { AllOperations, APIOperations } from './operations';
-export declare type APISchemas = CartSchema | CustomerSchema | LoginSchema | LogoutSchema | SignupSchema | ProductsSchema | WishlistSchema | CheckoutSchema | CustomerCardSchema | CustomerAddressSchema;
-export declare type GetAPISchema<C extends CommerceAPI<any>, S extends APISchemas = APISchemas> = {
-    schema: S;
-    endpoint: EndpointContext<C, S['endpoint']>;
-};
-export declare type EndpointContext<C extends CommerceAPI, E extends EndpointSchemaBase> = {
-    handler: Endpoint<C, E>;
-    handlers: EndpointHandlers<C, E>;
-};
-export declare type EndpointSchemaBase = {
-    options: {};
-    handlers: {
-        [k: string]: {
-            data?: any;
-            body?: any;
-        };
-    };
-};
-export declare type Endpoint<C extends CommerceAPI, E extends EndpointSchemaBase> = APIEndpoint<C, EndpointHandlers<C, E>, any, E['options']>;
-export declare type EndpointHandlers<C extends CommerceAPI, E extends EndpointSchemaBase> = {
-    [H in keyof E['handlers']]: APIHandler<C, EndpointHandlers<C, E>, NonNullable<E['handlers'][H]>['data'], NonNullable<E['handlers'][H]>['body'], E['options']>;
-};
-export declare type APIProvider = {
-    config: CommerceAPIConfig;
-    operations: APIOperations<any>;
-};
-export declare type CommerceAPI<P extends APIProvider = APIProvider> = CommerceAPICore<P> & AllOperations<P>;
-export declare class CommerceAPICore<P extends APIProvider = APIProvider> {
-    readonly provider: P;
-    constructor(provider: P);
-    getConfig(userConfig?: Partial<P['config']>): P['config'];
-    setConfig(newConfig: Partial<P['config']>): void;
-}
-export declare function getCommerceApi<P extends APIProvider>(customProvider: P): CommerceAPI<P>;
-export declare function getEndpoint<P extends APIProvider, T extends GetAPISchema<any, any>>(commerce: CommerceAPI<P>, context: T['endpoint'] & {
-    config?: P['config'];
-    options?: T['schema']['endpoint']['options'];
-}): NextApiHandler;
-export declare const createEndpoint: <API extends GetAPISchema<any, any>>(endpoint: API["endpoint"]) => <P extends APIProvider>(commerce: CommerceAPI<P>, context?: (Partial<API["endpoint"]> & {
-    config?: P["config"] | undefined;
-    options?: API["schema"]["endpoint"]["options"] | undefined;
-}) | undefined) => NextApiHandler;
-export interface CommerceAPIConfig {
-    locale?: string;
-    locales?: string[];
-    commerceUrl: string;
-    apiToken: string;
-    cartCookie: string;
-    cartCookieMaxAge: number;
-    customerCookie: string;
-    fetch<Data = any, Variables = any>(query: string, queryData?: CommerceAPIFetchOptions<Variables>, fetchOptions?: FetchOptions): Promise<GraphQLFetcherResult<Data>>;
-}
-export declare type GraphQLFetcher<Data extends GraphQLFetcherResult = GraphQLFetcherResult, Variables = any> = (query: string, queryData?: CommerceAPIFetchOptions<Variables>, fetchOptions?: FetchOptions) => Promise<Data>;
-export interface GraphQLFetcherResult<Data = any> {
-    data: Data;
-    res: Response;
-}
-export interface CommerceAPIFetchOptions<Variables> {
-    variables?: Variables;
-    preview?: boolean;
-}
+import type { NextApiHandler } from 'next';
+import type { FetchOptions, Response } from '@vercel/fetch';
+import type { APIEndpoint, APIHandler } from './utils/types';
+import type { CartSchema } from '../types/cart';
+import type { CustomerSchema } from '../types/customer';
+import type { LoginSchema } from '../types/login';
+import type { LogoutSchema } from '../types/logout';
+import type { SignupSchema } from '../types/signup';
+import type { ProductsSchema } from '../types/product';
+import type { WishlistSchema } from '../types/wishlist';
+import type { CheckoutSchema } from '../types/checkout';
+import type { CustomerCardSchema } from '../types/customer/card';
+import type { CustomerAddressSchema } from '../types/customer/address';
+import { AllOperations, APIOperations } from './operations';
+export type APISchemas = CartSchema | CustomerSchema | LoginSchema | LogoutSchema | SignupSchema | ProductsSchema | WishlistSchema | CheckoutSchema | CustomerCardSchema | CustomerAddressSchema;
+export type GetAPISchema<C extends CommerceAPI<any>, S extends APISchemas = APISchemas> = {
+    schema: S;
+    endpoint: EndpointContext<C, S['endpoint']>;
+};
+export type EndpointContext<C extends CommerceAPI, E extends EndpointSchemaBase> = {
+    handler: Endpoint<C, E>;
+    handlers: EndpointHandlers<C, E>;
+};
+export type EndpointSchemaBase = {
+    options: {};
+    handlers: {
+        [k: string]: {
+            data?: any;
+            body?: any;
+        };
+    };
+};
+export type Endpoint<C extends CommerceAPI, E extends EndpointSchemaBase> = APIEndpoint<C, EndpointHandlers<C, E>, any, E['options']>;
+export type EndpointHandlers<C extends CommerceAPI, E extends EndpointSchemaBase> = {
+    [H in keyof E['handlers']]: APIHandler<C, EndpointHandlers<C, E>, NonNullable<E['handlers'][H]>['data'], NonNullable<E['handlers'][H]>['body'], E['options']>;
+};
+export type APIProvider = {
+    config: CommerceAPIConfig;
+    operations: APIOperations<any>;
+};
+export type CommerceAPI<P extends APIProvider = APIProvider> = CommerceAPICore<P> & AllOperations<P>;
+export declare class CommerceAPICore<P extends APIProvider = APIProvider> {
+    readonly provider: P;
+    constructor(provider: P);
+    getConfig(userConfig?: Partial<P['config']>): P['config'];
+    setConfig(newConfig: Partial<P['config']>): void;
+}
+export declare function getCommerceApi<P extends APIProvider>(customProvider: P): CommerceAPI<P>;
+export declare function getEndpoint<P extends APIProvider, T extends GetAPISchema<any, any>>(commerce: CommerceAPI<P>, context: T['endpoint'] & {
+    config?: P['config'];
+    options?: T['schema']['endpoint']['options'];
+}): NextApiHandler;
+export declare const createEndpoint: <API extends GetAPISchema<any, any>>(endpoint: API["endpoint"]) => <P extends APIProvider>(commerce: CommerceAPI<P>, context?: (Partial<API["endpoint"]> & {
+    config?: P["config"] | undefined;
+    options?: API["schema"]["endpoint"]["options"] | undefined;
+}) | undefined) => NextApiHandler;
+export interface CommerceAPIConfig {
+    locale?: string;
+    locales?: string[];
+    commerceUrl: string;
+    apiToken: string;
+    cartCookie: string;
+    cartCookieMaxAge: number;
+    customerCookie: string;
+    fetch<Data = any, Variables = any>(query: string, queryData?: CommerceAPIFetchOptions<Variables>, fetchOptions?: FetchOptions): Promise<GraphQLFetcherResult<Data>>;
+}
+export type GraphQLFetcher<Data extends GraphQLFetcherResult = GraphQLFetcherResult, Variables = any> = (query: string, queryData?: CommerceAPIFetchOptions<Variables>, fetchOptions?: FetchOptions) => Promise<Data>;
+export interface GraphQLFetcherResult<Data = any> {
+    data: Data;
+    res: Response;
+}
+export interface CommerceAPIFetchOptions<Variables> {
+    variables?: Variables;
+    preview?: boolean;
+}

package/dist/api/operations.d.ts

@@ -1,130 +1,130 @@
-/// <reference types="node" />
-import type { ServerResponse } from 'http';
-import type { LoginOperation } from '../types/login';
-import type { GetAllPagesOperation, GetPageOperation } from '../types/page';
-import type { GetSiteInfoOperation } from '../types/site';
-import type { GetCustomerWishlistOperation } from '../types/wishlist';
-import type { GetAllProductPathsOperation, GetAllProductsOperation, GetProductOperation } from '../types/product';
-import type { APIProvider, CommerceAPI } from '.';
-declare const noop: () => never;
-export declare const OPERATIONS: readonly ["login", "getAllPages", "getPage", "getSiteInfo", "getCustomerWishlist", "getAllProductPaths", "getAllProducts", "getProduct"];
-export declare const defaultOperations: {
-    login: () => never;
-    getAllPages: () => never;
-    getPage: () => never;
-    getSiteInfo: () => never;
-    getCustomerWishlist: () => never;
-    getAllProductPaths: () => never;
-    getAllProducts: () => never;
-    getProduct: () => never;
-};
-export declare type AllowedOperations = typeof OPERATIONS[number];
-export declare type Operations<P extends APIProvider> = {
-    login: {
-        <T extends LoginOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            res: ServerResponse;
-        }): Promise<T['data']>;
-        <T extends LoginOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            res: ServerResponse;
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getAllPages: {
-        <T extends GetAllPagesOperation>(opts?: {
-            config?: P['config'];
-            preview?: boolean;
-        }): Promise<T['data']>;
-        <T extends GetAllPagesOperation>(opts: {
-            config?: P['config'];
-            preview?: boolean;
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getPage: {
-        <T extends GetPageOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            preview?: boolean;
-        }): Promise<T['data']>;
-        <T extends GetPageOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            preview?: boolean;
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getSiteInfo: {
-        <T extends GetSiteInfoOperation>(opts: {
-            config?: P['config'];
-            preview?: boolean;
-        }): Promise<T['data']>;
-        <T extends GetSiteInfoOperation>(opts: {
-            config?: P['config'];
-            preview?: boolean;
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getCustomerWishlist: {
-        <T extends GetCustomerWishlistOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            includeProducts?: boolean;
-        }): Promise<T['data']>;
-        <T extends GetCustomerWishlistOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            includeProducts?: boolean;
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getAllProductPaths: {
-        <T extends GetAllProductPathsOperation>(opts: {
-            variables?: T['variables'];
-            config?: P['config'];
-        }): Promise<T['data']>;
-        <T extends GetAllProductPathsOperation>(opts: {
-            variables?: T['variables'];
-            config?: P['config'];
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getAllProducts: {
-        <T extends GetAllProductsOperation>(opts: {
-            variables?: T['variables'];
-            config?: P['config'];
-            preview?: boolean;
-        }): Promise<T['data']>;
-        <T extends GetAllProductsOperation>(opts: {
-            variables?: T['variables'];
-            config?: P['config'];
-            preview?: boolean;
-        } & OperationOptions): Promise<T['data']>;
-    };
-    getProduct: {
-        <T extends GetProductOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            preview?: boolean;
-        }): Promise<T['data']>;
-        <T extends GetProductOperation>(opts: {
-            variables: T['variables'];
-            config?: P['config'];
-            preview?: boolean;
-        } & OperationOptions): Promise<T['data']>;
-    };
-};
-export declare type APIOperations<P extends APIProvider> = {
-    [K in keyof Operations<P>]?: (ctx: OperationContext<P>) => Operations<P>[K];
-};
-export declare type AllOperations<P extends APIProvider> = {
-    [K in keyof APIOperations<P>]-?: P['operations'][K] extends (...args: any) => any ? ReturnType<P['operations'][K]> : typeof noop;
-};
-export declare type OperationContext<P extends APIProvider> = {
-    commerce: CommerceAPI<P>;
-};
-export declare type OperationOptions = {
-    query: string;
-    url?: never;
-} | {
-    query?: never;
-    url: string;
-};
-export {};
+/// <reference types="node" />
+import type { ServerResponse } from 'http';
+import type { LoginOperation } from '../types/login';
+import type { GetAllPagesOperation, GetPageOperation } from '../types/page';
+import type { GetSiteInfoOperation } from '../types/site';
+import type { GetCustomerWishlistOperation } from '../types/wishlist';
+import type { GetAllProductPathsOperation, GetAllProductsOperation, GetProductOperation } from '../types/product';
+import type { APIProvider, CommerceAPI } from '.';
+declare const noop: () => never;
+export declare const OPERATIONS: readonly ["login", "getAllPages", "getPage", "getSiteInfo", "getCustomerWishlist", "getAllProductPaths", "getAllProducts", "getProduct"];
+export declare const defaultOperations: {
+    login: () => never;
+    getAllPages: () => never;
+    getPage: () => never;
+    getSiteInfo: () => never;
+    getCustomerWishlist: () => never;
+    getAllProductPaths: () => never;
+    getAllProducts: () => never;
+    getProduct: () => never;
+};
+export type AllowedOperations = typeof OPERATIONS[number];
+export type Operations<P extends APIProvider> = {
+    login: {
+        <T extends LoginOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            res: ServerResponse;
+        }): Promise<T['data']>;
+        <T extends LoginOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            res: ServerResponse;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getAllPages: {
+        <T extends GetAllPagesOperation>(opts?: {
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetAllPagesOperation>(opts: {
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getPage: {
+        <T extends GetPageOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetPageOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getSiteInfo: {
+        <T extends GetSiteInfoOperation>(opts: {
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetSiteInfoOperation>(opts: {
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getCustomerWishlist: {
+        <T extends GetCustomerWishlistOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            includeProducts?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetCustomerWishlistOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            includeProducts?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getAllProductPaths: {
+        <T extends GetAllProductPathsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+        }): Promise<T['data']>;
+        <T extends GetAllProductPathsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getAllProducts: {
+        <T extends GetAllProductsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetAllProductsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getProduct: {
+        <T extends GetProductOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetProductOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+};
+export type APIOperations<P extends APIProvider> = {
+    [K in keyof Operations<P>]?: (ctx: OperationContext<P>) => Operations<P>[K];
+};
+export type AllOperations<P extends APIProvider> = {
+    [K in keyof APIOperations<P>]-?: P['operations'][K] extends (...args: any) => any ? ReturnType<P['operations'][K]> : typeof noop;
+};
+export type OperationContext<P extends APIProvider> = {
+    commerce: CommerceAPI<P>;
+};
+export type OperationOptions = {
+    query: string;
+    url?: never;
+} | {
+    query?: never;
+    url: string;
+};
+export {};

package/dist/api/utils/errors.d.ts

@@ -1,10 +1,10 @@
-import type { Response } from '@vercel/fetch';
-export declare class CommerceAPIError extends Error {
-    status: number;
-    res: Response;
-    data: any;
-    constructor(msg: string, res: Response, data?: any);
-}
-export declare class CommerceNetworkError extends Error {
-    constructor(msg: string);
-}
+import type { Response } from '@vercel/fetch';
+export declare class CommerceAPIError extends Error {
+    status: number;
+    res: Response;
+    data: any;
+    constructor(msg: string, res: Response, data?: any);
+}
+export declare class CommerceNetworkError extends Error {
+    constructor(msg: string);
+}

package/dist/api/utils/is-allowed-method.d.ts

@@ -1,3 +1,3 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-export declare type HTTP_METHODS = 'OPTIONS' | 'GET' | 'POST' | 'PUT' | 'DELETE';
-export default function isAllowedMethod(req: NextApiRequest, res: NextApiResponse, allowedMethods: HTTP_METHODS[]): boolean;
+import type { NextApiRequest, NextApiResponse } from 'next';
+export type HTTP_METHODS = 'OPTIONS' | 'GET' | 'POST' | 'PUT' | 'DELETE';
+export default function isAllowedMethod(req: NextApiRequest, res: NextApiResponse, allowedMethods: HTTP_METHODS[]): boolean;

package/dist/api/utils/is-allowed-operation.d.ts

@@ -1,6 +1,6 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-import { HTTP_METHODS } from './is-allowed-method';
-import { APIHandler } from './types';
-export default function isAllowedOperation(req: NextApiRequest, res: NextApiResponse, allowedOperations: {
-    [k in HTTP_METHODS]?: APIHandler<any, any>;
-}): boolean;
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { HTTP_METHODS } from './is-allowed-method';
+import { APIHandler } from './types';
+export default function isAllowedOperation(req: NextApiRequest, res: NextApiResponse, allowedOperations: {
+    [k in HTTP_METHODS]?: APIHandler<any, any>;
+}): boolean;

package/dist/api/utils/types.d.ts

@@ -1,34 +1,34 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-import type { CommerceAPI } from '..';
-export declare type ErrorData = {
-    message: string;
-    code?: string;
-};
-export declare type APIResponse<Data = any> = {
-    data: Data;
-    errors?: ErrorData[];
-} | (Data extends null ? {
-    data: null;
-    errors?: ErrorData[];
-} : {
-    data: null;
-    errors: ErrorData[];
-});
-export declare type APIHandlerContext<C extends CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Options extends {} = {}> = {
-    req: NextApiRequest;
-    res: NextApiResponse<APIResponse<Data>>;
-    commerce: C;
-    config: C['provider']['config'];
-    handlers: H;
-    /**
-     * Custom configs that may be used by a particular handler
-     */
-    options: Options;
-};
-export declare type APIHandler<C extends CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Body = any, Options extends {} = {}> = (context: APIHandlerContext<C, H, Data, Options> & {
-    body: Body;
-}) => void | Promise<void>;
-export declare type APIHandlers<C extends CommerceAPI> = {
-    [k: string]: APIHandler<C, any, any, any, any>;
-};
-export declare type APIEndpoint<C extends CommerceAPI = CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Options extends {} = {}> = (context: APIHandlerContext<C, H, Data, Options>) => void | Promise<void>;
+import type { NextApiRequest, NextApiResponse } from 'next';
+import type { CommerceAPI } from '..';
+export type ErrorData = {
+    message: string;
+    code?: string;
+};
+export type APIResponse<Data = any> = {
+    data: Data;
+    errors?: ErrorData[];
+} | (Data extends null ? {
+    data: null;
+    errors?: ErrorData[];
+} : {
+    data: null;
+    errors: ErrorData[];
+});
+export type APIHandlerContext<C extends CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Options extends {} = {}> = {
+    req: NextApiRequest;
+    res: NextApiResponse<APIResponse<Data>>;
+    commerce: C;
+    config: C['provider']['config'];
+    handlers: H;
+    /**
+     * Custom configs that may be used by a particular handler
+     */
+    options: Options;
+};
+export type APIHandler<C extends CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Body = any, Options extends {} = {}> = (context: APIHandlerContext<C, H, Data, Options> & {
+    body: Body;
+}) => void | Promise<void>;
+export type APIHandlers<C extends CommerceAPI> = {
+    [k: string]: APIHandler<C, any, any, any, any>;
+};
+export type APIEndpoint<C extends CommerceAPI = CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Options extends {} = {}> = (context: APIHandlerContext<C, H, Data, Options>) => void | Promise<void>;

package/dist/cart/use-add-item.d.ts

@@ -1,5 +1,5 @@
-import type { MutationHook } from '../utils/types';
-import type { AddItemHook } from '../types/cart';
-export declare type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
-declare const useAddItem: UseAddItem;
-export default useAddItem;
+import type { MutationHook } from '../utils/types';
+import type { AddItemHook } from '../types/cart';
+export type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
+declare const useAddItem: UseAddItem;
+export default useAddItem;

package/dist/cart/use-cart.d.ts

@@ -1,5 +1,5 @@
-import type { SWRHook } from '../utils/types';
-import type { GetCartHook } from '../types/cart';
-export declare type UseCart<H extends SWRHook<GetCartHook<any>> = SWRHook<GetCartHook>> = ReturnType<H['useHook']>;
-declare const useCart: UseCart;
-export default useCart;
+import type { SWRHook } from '../utils/types';
+import type { GetCartHook } from '../types/cart';
+export type UseCart<H extends SWRHook<GetCartHook<any>> = SWRHook<GetCartHook>> = ReturnType<H['useHook']>;
+declare const useCart: UseCart;
+export default useCart;

package/dist/cart/use-remove-item.d.ts

@@ -1,5 +1,5 @@
-import type { MutationHook } from '../utils/types';
-import type { RemoveItemHook } from '../types/cart';
-export declare type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
-declare const useRemoveItem: UseRemoveItem;
-export default useRemoveItem;
+import type { MutationHook } from '../utils/types';
+import type { RemoveItemHook } from '../types/cart';
+export type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
+declare const useRemoveItem: UseRemoveItem;
+export default useRemoveItem;

package/dist/cart/use-update-item.d.ts

@@ -1,5 +1,5 @@
-import type { MutationHook } from '../utils/types';
-import type { UpdateItemHook } from '../types/cart';
-export declare type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
-declare const useUpdateItem: UseUpdateItem;
-export default useUpdateItem;
+import type { MutationHook } from '../utils/types';
+import type { UpdateItemHook } from '../types/cart';
+export type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
+declare const useUpdateItem: UseUpdateItem;
+export default useUpdateItem;