@01.software/sdk 0.29.0 → 0.30.1

package/dist/query.d.ts

@@ -0,0 +1,244 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient, InfiniteData, UseQueryResult } from '@tanstack/react-query';
+import { A as ApiQueryOptions, P as PayloadFindResponse, g as PayloadMutationResponse, I as CustomerAuth, M as CustomerProfile, K as CustomerAuthResponse, L as CustomerLoginData, Q as CustomerRegisterResponse, O as CustomerRegisterData, N as CustomerRefreshResponse, aS as UpdateProfileData, ab as ProductDetailParams, a2 as ProductDetail, al as ProductListingGroupsItem, h as RootClient } from './types-DuSKPiY5.js';
+import './payload-types-DPjO_IbQ.js';
+import { C as CollectionClient } from './collection-client-B9d9kr1d.js';
+import { c as ServerCollection, P as PublicCollection } from './const-B75IFDRi.js';
+import { C as CollectionType } from './types-1fBLrYU7.js';
+import { S as SDKError } from './index-B2WbhEgT.js';
+export { a as RealtimeConnection, R as RealtimeEvent, b as RealtimeListener } from './realtime-D7HtUpqt.js';
+import { ServerClient } from './server.js';
+import './metadata.js';
+
+declare function getQueryClient(): QueryClient;
+
+interface CollectionQueryParams<T extends ServerCollection> {
+    collection: T;
+    options?: ApiQueryOptions;
+}
+interface CollectionDetailQueryParams<T extends ServerCollection> {
+    collection: T;
+    id: string;
+    options?: ApiQueryOptions;
+}
+interface CollectionInfiniteQueryParams<T extends ServerCollection> {
+    collection: T;
+    options?: Omit<ApiQueryOptions, 'page'>;
+    pageSize?: number;
+}
+interface QueryOptions<TQueryFnData = unknown, TData = TQueryFnData> {
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+    refetchOnWindowFocus?: boolean;
+    refetchOnMount?: boolean | 'always';
+    refetchInterval?: number | false;
+    retry?: boolean | number;
+    select?: (data: TQueryFnData) => TData;
+    placeholderData?: TQueryFnData | ((previousData: TData | undefined) => TQueryFnData | undefined);
+    initialData?: TQueryFnData | (() => TQueryFnData);
+    initialDataUpdatedAt?: number | (() => number | undefined);
+}
+type SuspenseQueryOptions<TQueryFnData = unknown, TData = TQueryFnData> = Omit<QueryOptions<TQueryFnData, TData>, 'enabled' | 'placeholderData'>;
+interface InfiniteQueryOptions<TQueryFnData = unknown, TData = InfiniteData<TQueryFnData>> {
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+    refetchOnWindowFocus?: boolean;
+    refetchOnMount?: boolean | 'always';
+    refetchInterval?: number | false;
+    retry?: boolean | number;
+    select?: (data: InfiniteData<TQueryFnData>) => TData;
+}
+type SuspenseInfiniteQueryOptions<TQueryFnData = unknown, TData = InfiniteData<TQueryFnData>> = Omit<InfiniteQueryOptions<TQueryFnData, TData>, 'enabled'>;
+interface MutationCallbacks$1<TData> {
+    onSuccess?: (data: TData) => void;
+    onError?: (error: SDKError) => void;
+    onSettled?: () => void;
+}
+declare class CollectionHooks<TCollection extends ServerCollection = PublicCollection> {
+    protected queryClient: QueryClient;
+    protected collectionClient: CollectionClient<TCollection>;
+    constructor(queryClient: QueryClient, collectionClient: CollectionClient<TCollection>);
+    useQuery<T extends TCollection, TData = PayloadFindResponse<CollectionType<T>>>(params: CollectionQueryParams<T>, options?: QueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<TData>, Error>;
+    useSuspenseQuery<T extends TCollection, TData = PayloadFindResponse<CollectionType<T>>>(params: CollectionQueryParams<T>, options?: SuspenseQueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseSuspenseQueryResult<TData, Error>;
+    useQueryById<T extends TCollection, TData = CollectionType<T>>(params: CollectionDetailQueryParams<T>, options?: QueryOptions<CollectionType<T>, TData>): _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<TData>, Error>;
+    useSuspenseQueryById<T extends TCollection, TData = CollectionType<T>>(params: CollectionDetailQueryParams<T>, options?: SuspenseQueryOptions<CollectionType<T>, TData>): _tanstack_react_query.UseSuspenseQueryResult<TData, Error>;
+    useInfiniteQuery<T extends TCollection, TData = InfiniteData<PayloadFindResponse<CollectionType<T>>>>(params: CollectionInfiniteQueryParams<T>, options?: InfiniteQueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseInfiniteQueryResult<TData, Error>;
+    useSuspenseInfiniteQuery<T extends TCollection, TData = InfiniteData<PayloadFindResponse<CollectionType<T>>>>(params: CollectionInfiniteQueryParams<T>, options?: SuspenseInfiniteQueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseSuspenseInfiniteQueryResult<TData, Error>;
+    prefetchQuery<T extends TCollection>(params: CollectionQueryParams<T>, options?: {
+        staleTime?: number;
+    }): Promise<void>;
+    prefetchQueryById<T extends TCollection>(params: CollectionDetailQueryParams<T>, options?: {
+        staleTime?: number;
+    }): Promise<void>;
+    prefetchInfiniteQuery<T extends TCollection>(params: CollectionInfiniteQueryParams<T>, options?: {
+        pages?: number;
+        staleTime?: number;
+    }): Promise<void>;
+    useCreate<T extends TCollection>(params: {
+        collection: T;
+    }, options?: MutationCallbacks$1<PayloadMutationResponse<CollectionType<T>>>): _tanstack_react_query.UseMutationResult<PayloadMutationResponse<CollectionType<T>>, SDKError, {
+        data: Partial<CollectionType<T>>;
+        file?: File | Blob;
+        filename?: string;
+    }, unknown>;
+    useUpdate<T extends TCollection>(params: {
+        collection: T;
+    }, options?: MutationCallbacks$1<PayloadMutationResponse<CollectionType<T>>>): _tanstack_react_query.UseMutationResult<PayloadMutationResponse<CollectionType<T>>, SDKError, {
+        id: string;
+        data: Partial<CollectionType<T>>;
+        file?: File | Blob;
+        filename?: string;
+    }, unknown>;
+    useRemove<T extends TCollection>(params: {
+        collection: T;
+    }, options?: MutationCallbacks$1<CollectionType<T>>): _tanstack_react_query.UseMutationResult<CollectionType<T>, SDKError, string, unknown>;
+    invalidateQueries<T extends TCollection>(collection: T, type?: 'list' | 'detail' | 'infinite'): Promise<void>;
+    getQueryData<T extends TCollection>(collection: T, type: 'list', options?: ApiQueryOptions): PayloadFindResponse<CollectionType<T>> | undefined;
+    getQueryData<T extends TCollection>(collection: T, type: 'detail', id: string, options?: ApiQueryOptions): CollectionType<T> | null | undefined;
+    setQueryData<T extends TCollection>(collection: T, type: 'list', data: PayloadFindResponse<CollectionType<T>>, options?: ApiQueryOptions): void;
+    setQueryData<T extends TCollection>(collection: T, type: 'detail', id: string, data: CollectionType<T> | null, options?: ApiQueryOptions): void;
+}
+
+interface MutationCallbacks<TData> {
+    onSuccess?: (data: TData) => void;
+    onError?: (error: SDKError) => void;
+    onSettled?: () => void;
+}
+declare class CustomerHooks {
+    private queryClient;
+    private customerAuth?;
+    constructor(queryClient: QueryClient, customerAuth?: CustomerAuth);
+    private ensureCustomerAuth;
+    private invalidateMe;
+    useCustomerMe(options?: {
+        enabled?: boolean;
+        staleTime?: number;
+        gcTime?: number;
+        refetchOnWindowFocus?: boolean;
+        refetchOnMount?: boolean | 'always';
+        refetchInterval?: number | false;
+        retry?: boolean | number;
+    }): _tanstack_react_query.UseQueryResult<CustomerProfile | null, Error>;
+    useCustomerLogin(options?: MutationCallbacks<CustomerAuthResponse>): _tanstack_react_query.UseMutationResult<CustomerAuthResponse, SDKError, CustomerLoginData, unknown>;
+    useCustomerRegister(options?: MutationCallbacks<{
+        customer: CustomerProfile;
+    }>): _tanstack_react_query.UseMutationResult<CustomerRegisterResponse, SDKError, CustomerRegisterData, unknown>;
+    useCustomerLogout(options?: MutationCallbacks<void>): _tanstack_react_query.UseMutationResult<void, SDKError, void, unknown>;
+    useCustomerForgotPassword(options?: MutationCallbacks<void>): _tanstack_react_query.UseMutationResult<void, SDKError, string, unknown>;
+    useCustomerResetPassword(options?: MutationCallbacks<void>): _tanstack_react_query.UseMutationResult<void, SDKError, {
+        token: string;
+        password: string;
+    }, unknown>;
+    useCustomerRefreshToken(options?: MutationCallbacks<CustomerRefreshResponse>): _tanstack_react_query.UseMutationResult<CustomerRefreshResponse, SDKError, unknown, unknown>;
+    useCustomerUpdateProfile(options?: MutationCallbacks<CustomerProfile>): _tanstack_react_query.UseMutationResult<CustomerProfile, SDKError, UpdateProfileData, unknown>;
+    useCustomerChangePassword(options?: MutationCallbacks<void>): _tanstack_react_query.UseMutationResult<void, SDKError, {
+        currentPassword: string;
+        newPassword: string;
+    }, unknown>;
+    invalidateCustomerQueries(): Promise<void>;
+    getCustomerData(): CustomerProfile | null | undefined;
+    setCustomerData(data: CustomerProfile | null): void;
+}
+
+type ProductListingGroupsQueryOptions = Pick<ApiQueryOptions, 'page' | 'limit' | 'sort' | 'where'>;
+type ReadOnlyQueryHooks = Omit<QueryHooks<PublicCollection>, 'useCreate' | 'useUpdate' | 'useRemove'>;
+/**
+ * Composes CollectionHooks + CustomerHooks into a single API surface.
+ * All methods are delegated; no logic lives here.
+ */
+interface ProductDetailCallable {
+    product: {
+        detail: (params: ProductDetailParams) => Promise<ProductDetail | null>;
+    };
+}
+declare class QueryHooks<TCollection extends ServerCollection = PublicCollection> extends CollectionHooks<TCollection> {
+    private _customer;
+    private _commerce?;
+    constructor(queryClient: QueryClient, collectionClient: CollectionClient<TCollection>, customerAuth?: CustomerAuth, commerceClient?: ProductDetailCallable);
+    useCustomerMe: CustomerHooks['useCustomerMe'];
+    useCustomerLogin: CustomerHooks['useCustomerLogin'];
+    useCustomerRegister: CustomerHooks['useCustomerRegister'];
+    useCustomerLogout: CustomerHooks['useCustomerLogout'];
+    useCustomerForgotPassword: CustomerHooks['useCustomerForgotPassword'];
+    useCustomerResetPassword: CustomerHooks['useCustomerResetPassword'];
+    useCustomerRefreshToken: CustomerHooks['useCustomerRefreshToken'];
+    useCustomerUpdateProfile: CustomerHooks['useCustomerUpdateProfile'];
+    useCustomerChangePassword: CustomerHooks['useCustomerChangePassword'];
+    invalidateCustomerQueries: CustomerHooks['invalidateCustomerQueries'];
+    getCustomerData: CustomerHooks['getCustomerData'];
+    setCustomerData: CustomerHooks['setCustomerData'];
+    useProductListingGroupsQuery<TData = PayloadFindResponse<ProductListingGroupsItem>>(params: {
+        options?: ProductListingGroupsQueryOptions;
+    }, options?: QueryOptions<PayloadFindResponse<ProductListingGroupsItem>, TData>): UseQueryResult<_tanstack_react_query.NoInfer<TData>, Error>;
+    useSuspenseProductListingGroupsQuery<TData = PayloadFindResponse<ProductListingGroupsItem>>(params: {
+        options?: ProductListingGroupsQueryOptions;
+    }, options?: SuspenseQueryOptions<PayloadFindResponse<ProductListingGroupsItem>, TData>): _tanstack_react_query.UseSuspenseQueryResult<TData, Error>;
+    useInfiniteProductListingGroupsQuery<TData = InfiniteData<PayloadFindResponse<ProductListingGroupsItem>>>(params: {
+        options?: Omit<ProductListingGroupsQueryOptions, 'page' | 'limit'>;
+        pageSize?: number;
+    }, options?: InfiniteQueryOptions<PayloadFindResponse<ProductListingGroupsItem>, TData>): _tanstack_react_query.UseInfiniteQueryResult<TData, Error>;
+    useSuspenseInfiniteProductListingGroupsQuery<TData = InfiniteData<PayloadFindResponse<ProductListingGroupsItem>>>(params: {
+        options?: Omit<ProductListingGroupsQueryOptions, 'page' | 'limit'>;
+        pageSize?: number;
+    }, options?: SuspenseInfiniteQueryOptions<PayloadFindResponse<ProductListingGroupsItem>, TData>): _tanstack_react_query.UseSuspenseInfiniteQueryResult<TData, Error>;
+    prefetchProductListingGroupsQuery(params: {
+        options?: ProductListingGroupsQueryOptions;
+    }, options?: {
+        staleTime?: number;
+    }): Promise<void>;
+    prefetchInfiniteProductListingGroupsQuery(params: {
+        options?: Omit<ProductListingGroupsQueryOptions, 'page' | 'limit'>;
+        pageSize?: number;
+    }, options?: {
+        pages?: number;
+        staleTime?: number;
+    }): Promise<void>;
+    useProductDetail(params: {
+        slug: string;
+    } | {
+        id: string;
+    }, options?: {
+        enabled?: boolean;
+    }): UseQueryResult<ProductDetail | null>;
+    useProductDetailBySlug(slug: string, options?: {
+        enabled?: boolean;
+    }): UseQueryResult<ProductDetail | null>;
+    useProductDetailById(id: string, options?: {
+        enabled?: boolean;
+    }): UseQueryResult<ProductDetail | null>;
+}
+
+declare function collectionKeys<T extends ServerCollection>(collection: T): {
+    all: readonly [T];
+    lists: () => readonly [T, "list"];
+    list: (options?: ApiQueryOptions) => readonly [T, "list", ApiQueryOptions | undefined];
+    details: () => readonly [T, "detail"];
+    detail: (id: string, options?: ApiQueryOptions) => readonly [T, "detail", string, ApiQueryOptions | undefined];
+    infinites: () => readonly [T, "infinite"];
+    infinite: (options?: Omit<ApiQueryOptions, "page">) => readonly [T, "infinite", Omit<ApiQueryOptions, "page"> | undefined];
+};
+declare const customerKeys: {
+    all: readonly ["customer"];
+    me: () => readonly ["customer", "me"];
+};
+declare const productKeys: {
+    listingGroups: (options?: ProductListingGroupsQueryOptions) => readonly ["products", "listing-groups", "list", ProductListingGroupsQueryOptions | undefined];
+    listingGroupsInfinite: (options?: Omit<ProductListingGroupsQueryOptions, "page" | "limit">) => readonly ["products", "listing-groups", "infinite", Omit<ProductListingGroupsQueryOptions, "page" | "limit"> | undefined];
+    detail: (params: {
+        slug: string;
+    } | {
+        id: string;
+    }) => readonly ["products", "detail", {
+        slug: string;
+    } | {
+        id: string;
+    }];
+    detailAll: () => readonly ["products", "detail"];
+};
+
+declare function createQueryHooks(client: RootClient, queryClient?: QueryClient): ReadOnlyQueryHooks;
+declare function createServerQueryHooks(client: ServerClient, queryClient?: QueryClient): QueryHooks<ServerCollection>;
+
+export { type CollectionDetailQueryParams, CollectionHooks, type CollectionInfiniteQueryParams, type CollectionQueryParams, CustomerHooks, type InfiniteQueryOptions, type ProductListingGroupsQueryOptions, QueryHooks, type QueryOptions, type ReadOnlyQueryHooks, type SuspenseInfiniteQueryOptions, type SuspenseQueryOptions, collectionKeys, createQueryHooks, createServerQueryHooks, customerKeys, getQueryClient, productKeys };