@01.software/sdk 0.21.0 → 0.22.0

package/dist/server-BARh_6zH.d.ts

@@ -0,0 +1,1397 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient, InfiniteData } from '@tanstack/react-query';
+import { O as Order, c as Cart, d as CartItem, e as Product, k as OrderItem, l as Transaction, m as Fulfillment, n as Return } from './payload-types-DeLBmtzd.js';
+import { Sort, Where } from 'payload';
+import { Metadata } from 'next';
+import { C as CollectionType } from './types-KkuKwsli.js';
+import { P as PublicCollection } from './const-CfcjPbOu.js';
+
+declare function resolveApiUrl(): string;
+interface ClientConfig {
+    publishableKey: string;
+    /**
+     * Customer authentication options.
+     * Used to initialize CustomerAuth on Client.
+     */
+    customer?: {
+        /**
+         * Persist token in localStorage. Defaults to `true`.
+         * - `true` (default): uses key `'customer-token'`
+         * - `string`: uses the given string as localStorage key
+         * - `false`: disables persistence (token/onTokenChange used instead)
+         *
+         * Handles SSR safely (no-op on server).
+         * When enabled, `token` and `onTokenChange` are ignored.
+         */
+        persist?: boolean | string;
+        /** Initial token (e.g. from SSR cookie) */
+        token?: string;
+        /** Called when token changes (login/logout) — use to persist in localStorage/cookie */
+        onTokenChange?: (token: string | null) => void;
+    };
+}
+interface ClientServerConfig extends ClientConfig {
+    secretKey: string;
+}
+interface ClientMetadata {
+    userAgent?: string;
+    timestamp: number;
+}
+interface ClientState {
+    metadata: ClientMetadata;
+}
+interface PaginationMeta {
+    page: number;
+    limit: number;
+    totalDocs: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    pagingCounter: number;
+    prevPage: number | null;
+    nextPage: number | null;
+}
+/**
+ * Payload CMS Find (List) Response
+ * GET /api/{collection}
+ */
+interface PayloadFindResponse<T = unknown> {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    totalPages: number;
+    page: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+}
+/**
+ * Payload CMS Create/Update Response
+ * POST /api/{collection}
+ * PATCH /api/{collection}/{id}
+ */
+interface PayloadMutationResponse<T = unknown> {
+    message: string;
+    doc: T;
+    errors?: unknown[];
+}
+/**
+ * Do NOT replace with `Pick<FindOptions>` from `payload`. Payload's generic
+ * types (`JoinQuery<TSlug>`, `PopulateType`) depend on `PayloadTypes` module
+ * augmentation; external SDK consumers who skip that get degenerate types
+ * (`never` / `{}`). Only non-generic `Sort`/`Where` are safe to import.
+ * Excluded vs native: Local-API-only fields, `locale`/`fallbackLocale`.
+ */
+interface ApiQueryOptions {
+    page?: number;
+    limit?: number;
+    sort?: Sort;
+    where?: Where;
+    depth?: number;
+    select?: Record<string, boolean>;
+    /** Per-collection field selection for populated relationships (keyed by collection slug) */
+    populate?: Record<string, boolean | Record<string, boolean>>;
+    /** Join field control: pagination/filter per join, or false to disable */
+    joins?: Record<string, {
+        limit?: number;
+        page?: number;
+        sort?: string;
+        where?: Where;
+        count?: boolean;
+    } | false> | false;
+    /** Set to `false` to skip the count query — returns docs without totalDocs/totalPages */
+    pagination?: boolean;
+    /** Include draft versions (access control still applies on the server) */
+    draft?: boolean;
+    /** Include soft-deleted documents (requires `trash` enabled on the collection) */
+    trash?: boolean;
+}
+interface DebugConfig {
+    logRequests?: boolean;
+    logResponses?: boolean;
+    logErrors?: boolean;
+}
+interface RetryConfig {
+    maxRetries?: number;
+    retryableStatuses?: number[];
+    retryDelay?: (attempt: number) => number;
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type ExtractArrayType<T> = T extends (infer U)[] ? U : never;
+
+interface GenerateMetadataOptions {
+    siteName?: string;
+}
+
+declare class SDKError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    readonly details?: unknown;
+    readonly userMessage?: string;
+    readonly suggestion?: string;
+    readonly requestId?: string;
+    constructor(code: string, message: string, status?: number, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string);
+    getUserMessage(): string;
+    toJSON(): {
+        requestId?: string | undefined;
+        name: string;
+        code: string;
+        message: string;
+        status: number | undefined;
+        details: unknown;
+        userMessage: string | undefined;
+        suggestion: string | undefined;
+    };
+}
+declare class NetworkError extends SDKError {
+    constructor(message: string, status?: number, details?: unknown, userMessage?: string, suggestion?: string);
+}
+declare class ValidationError extends SDKError {
+    constructor(message: string, details?: unknown, userMessage?: string, suggestion?: string, status?: number);
+}
+declare class ApiError extends SDKError {
+    constructor(message: string, status: number, details?: unknown, userMessage?: string, suggestion?: string);
+}
+declare class ConfigError extends SDKError {
+    constructor(message: string, details?: unknown, userMessage?: string, suggestion?: string);
+}
+declare class TimeoutError extends SDKError {
+    constructor(message?: string, details?: unknown, userMessage?: string, suggestion?: string);
+}
+declare class GoneError extends SDKError {
+    constructor(message?: string, details?: unknown, userMessage?: string, suggestion?: string);
+}
+declare class ServiceUnavailableError extends SDKError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number, details?: unknown, userMessage?: string, suggestion?: string);
+}
+declare class UsageLimitError extends SDKError {
+    readonly usage: {
+        limit: number;
+        current: number;
+        remaining: number;
+    };
+    constructor(message: string, usage: {
+        limit: number;
+        current: number;
+        remaining: number;
+    }, details?: unknown, userMessage?: string, suggestion?: string);
+    toJSON(): {
+        usage: {
+            limit: number;
+            current: number;
+            remaining: number;
+        };
+        requestId?: string | undefined;
+        name: string;
+        code: string;
+        message: string;
+        status: number | undefined;
+        details: unknown;
+        userMessage: string | undefined;
+        suggestion: string | undefined;
+    };
+}
+declare class AuthError extends SDKError {
+    constructor(message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string);
+}
+declare class PermissionError extends SDKError {
+    constructor(message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string);
+}
+declare class NotFoundError extends SDKError {
+    constructor(message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string);
+}
+declare class ConflictError extends SDKError {
+    constructor(message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string);
+}
+declare class RateLimitError extends SDKError {
+    readonly retryAfter?: number;
+    constructor(message: string, retryAfter?: number, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string);
+}
+declare function isSDKError(error: unknown): error is SDKError;
+declare function isNetworkError(error: unknown): error is NetworkError;
+declare function isValidationError(error: unknown): error is ValidationError;
+declare function isApiError(error: unknown): error is ApiError;
+declare function isConfigError(error: unknown): error is ConfigError;
+declare function isTimeoutError(error: unknown): error is TimeoutError;
+declare function isGoneError(error: unknown): error is GoneError;
+declare function isServiceUnavailableError(error: unknown): error is ServiceUnavailableError;
+declare function isUsageLimitError(error: unknown): error is UsageLimitError;
+declare function isAuthError(error: unknown): error is AuthError;
+declare function isPermissionError(error: unknown): error is PermissionError;
+declare function isNotFoundError(error: unknown): error is NotFoundError;
+declare function isConflictError(error: unknown): error is ConflictError;
+declare function isRateLimitError(error: unknown): error is RateLimitError;
+declare const createAuthError: (message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string) => AuthError;
+declare const createPermissionError: (message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string) => PermissionError;
+declare const createNotFoundError: (message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string) => NotFoundError;
+declare const createConflictError: (message: string, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string) => ConflictError;
+declare const createRateLimitError: (message: string, retryAfter?: number, details?: unknown, userMessage?: string, suggestion?: string, requestId?: string) => RateLimitError;
+
+interface FetchOptions extends RequestInit {
+    publishableKey?: string;
+    secretKey?: string;
+    customerToken?: string;
+    timeout?: number;
+    debug?: boolean | DebugConfig;
+    retry?: RetryConfig;
+    /** Called on 401 when customerToken is set and reason=token_expired. Return a new token to retry, or null to fail. */
+    onUnauthorized?: () => Promise<string | null>;
+}
+
+declare class HttpClient {
+    protected publishableKey: string;
+    protected secretKey?: string;
+    private getCustomerToken?;
+    private onUnauthorized?;
+    private onRequestId?;
+    constructor(publishableKey: string, secretKey?: string, getCustomerToken?: () => string | null, onUnauthorized?: () => Promise<string | null>, onRequestId?: (id: string | null) => void);
+    protected get defaultOptions(): FetchOptions;
+    protected fetchWithTracking(url: string, opts: FetchOptions): Promise<Response>;
+    protected buildUrl(endpoint: string, options?: ApiQueryOptions): string;
+    protected assertJsonResponse(response: Response): void;
+    /**
+     * Parse Payload CMS find response (list query)
+     * Returns native Payload response structure
+     */
+    protected parseFindResponse<T>(response: Response): Promise<PayloadFindResponse<T>>;
+    /**
+     * Parse Payload CMS mutation response (create/update)
+     * Returns native Payload response structure
+     */
+    protected parseMutationResponse<T>(response: Response): Promise<PayloadMutationResponse<T>>;
+    /**
+     * Parse Payload CMS document response (findById/delete)
+     * Returns document directly without wrapper
+     */
+    protected parseDocumentResponse<T>(response: Response): Promise<T>;
+}
+
+declare class CollectionClient extends HttpClient {
+    from<T extends PublicCollection>(collection: T): CollectionQueryBuilder<T>;
+    /**
+     * Find documents (list query)
+     * GET /api/{collection}
+     */
+    requestFind<T = unknown>(endpoint: string, options?: ApiQueryOptions): Promise<PayloadFindResponse<T>>;
+    /**
+     * Find-like response from a custom endpoint
+     * POST /api/...custom-endpoint
+     */
+    requestFindEndpoint<T = unknown>(endpoint: string, data?: unknown): Promise<PayloadFindResponse<T>>;
+    /**
+     * Find document by ID
+     * GET /api/{collection}/{id}
+     */
+    requestFindById<T = unknown>(endpoint: string, options?: ApiQueryOptions): Promise<T>;
+    /**
+     * Create document
+     * POST /api/{collection}
+     */
+    requestCreate<T = unknown>(endpoint: string, data?: unknown): Promise<PayloadMutationResponse<T>>;
+    /**
+     * Update document
+     * PATCH /api/{collection}/{id}
+     */
+    requestUpdate<T = unknown>(endpoint: string, data?: unknown): Promise<PayloadMutationResponse<T>>;
+    /**
+     * Count documents
+     * GET /api/{collection}/count
+     */
+    requestCount(endpoint: string, options?: ApiQueryOptions): Promise<{
+        totalDocs: number;
+    }>;
+    /**
+     * Update multiple documents (bulk update)
+     * PATCH /api/{collection}
+     */
+    requestUpdateMany<T = unknown>(endpoint: string, data: {
+        where?: unknown;
+        data: unknown;
+    }): Promise<PayloadFindResponse<T>>;
+    /**
+     * Delete document
+     * DELETE /api/{collection}/{id}
+     */
+    requestDelete<T = unknown>(endpoint: string): Promise<T>;
+    /**
+     * Delete multiple documents (bulk delete)
+     * DELETE /api/{collection}
+     */
+    requestDeleteMany<T = unknown>(endpoint: string, data: {
+        where?: unknown;
+    }): Promise<PayloadFindResponse<T>>;
+    /**
+     * Create document with file upload
+     * POST /api/{collection} (multipart/form-data)
+     */
+    requestCreateWithFile<T = unknown>(endpoint: string, data: unknown, file: File | Blob, filename?: string): Promise<PayloadMutationResponse<T>>;
+    /**
+     * Update document with file upload
+     * PATCH /api/{collection}/{id} (multipart/form-data)
+     */
+    requestUpdateWithFile<T = unknown>(endpoint: string, data: unknown, file: File | Blob, filename?: string): Promise<PayloadMutationResponse<T>>;
+}
+declare class ReadOnlyCollectionClient extends HttpClient {
+    from<T extends PublicCollection>(collection: T): ReadOnlyQueryBuilder<T>;
+    requestFind<T = unknown>(endpoint: string, options?: ApiQueryOptions): Promise<PayloadFindResponse<T>>;
+    requestFindById<T = unknown>(endpoint: string, options?: ApiQueryOptions): Promise<T>;
+    requestCount(endpoint: string, options?: ApiQueryOptions): Promise<{
+        totalDocs: number;
+    }>;
+}
+
+type ReadOnlyCollectionApi = Pick<CollectionClient, 'requestFind' | 'requestFindById' | 'requestCount'>;
+/**
+ * Read-only subset of CollectionQueryBuilder.
+ * Client.from() returns this type to prevent write operations at compile time.
+ */
+type ReadOnlyQueryBuilder<T extends PublicCollection> = ReadOnlyCollectionQueryBuilder<T>;
+declare class ReadOnlyCollectionQueryBuilder<T extends PublicCollection> {
+    private api;
+    private collection;
+    constructor(api: ReadOnlyCollectionApi, collection: T);
+    find(options?: ApiQueryOptions): Promise<PayloadFindResponse<CollectionType<T>>>;
+    findById(id: string | number, options?: ApiQueryOptions): Promise<CollectionType<T>>;
+    count(options?: ApiQueryOptions): Promise<{
+        totalDocs: number;
+    }>;
+    findMetadata(options?: ApiQueryOptions, metadataOptions?: GenerateMetadataOptions): Promise<Metadata | null>;
+    findMetadataById(id: string, metadataOptions?: GenerateMetadataOptions): Promise<Metadata>;
+}
+declare class CollectionQueryBuilder<T extends PublicCollection> {
+    private api;
+    private collection;
+    constructor(api: CollectionClient, collection: T);
+    /**
+     * Find documents (list query)
+     * GET /api/{collection}
+     * @returns Payload CMS find response with docs array and pagination
+     */
+    find(options?: ApiQueryOptions): Promise<PayloadFindResponse<CollectionType<T>>>;
+    /**
+     * Find document by ID
+     * GET /api/{collection}/{id}
+     * @returns Document object directly (no wrapper)
+     */
+    findById(id: string | number, options?: ApiQueryOptions): Promise<CollectionType<T>>;
+    /**
+     * Create a new document
+     * POST /api/{collection}
+     * @returns Payload CMS mutation response with doc and message
+     */
+    create(data: Partial<CollectionType<T>>, options?: {
+        file?: File | Blob;
+        filename?: string;
+    }): Promise<PayloadMutationResponse<CollectionType<T>>>;
+    /**
+     * Update a document by ID
+     * PATCH /api/{collection}/{id}
+     * @returns Payload CMS mutation response with doc and message
+     */
+    update(id: string, data: Partial<CollectionType<T>>, options?: {
+        file?: File | Blob;
+        filename?: string;
+    }): Promise<PayloadMutationResponse<CollectionType<T>>>;
+    /**
+     * Count documents
+     * GET /api/{collection}/count
+     * @returns Count response with totalDocs
+     */
+    count(options?: ApiQueryOptions): Promise<{
+        totalDocs: number;
+    }>;
+    /**
+     * Find first matching document and return its Next.js Metadata.
+     * Applies depth: 1 (SEO image populate) and limit: 1 automatically.
+     * @returns Metadata or null if no document matches
+     */
+    findMetadata(options?: ApiQueryOptions, metadataOptions?: GenerateMetadataOptions): Promise<Metadata | null>;
+    /**
+     * Find document by ID and return its Next.js Metadata.
+     * Applies depth: 1 (SEO image populate) automatically.
+     * @returns Metadata (throws on 404)
+     */
+    findMetadataById(id: string, metadataOptions?: GenerateMetadataOptions): Promise<Metadata>;
+    /**
+     * Update multiple documents (bulk update)
+     * PATCH /api/{collection}
+     * @returns Payload CMS find response with updated docs
+     */
+    updateMany(where: ApiQueryOptions['where'], data: Partial<CollectionType<T>>): Promise<PayloadFindResponse<CollectionType<T>>>;
+    /**
+     * Delete a document by ID
+     * DELETE /api/{collection}/{id}
+     * @returns Deleted document object directly (no wrapper)
+     */
+    remove(id: string): Promise<CollectionType<T>>;
+    /**
+     * Delete multiple documents (bulk delete)
+     * DELETE /api/{collection}
+     * @returns Payload CMS find response with deleted docs
+     */
+    removeMany(where: ApiQueryOptions['where']): Promise<PayloadFindResponse<CollectionType<T>>>;
+}
+
+interface CommunityClientOptions {
+    publishableKey?: string;
+    secretKey?: string;
+    customerToken?: string | (() => string | null);
+    onUnauthorized?: () => Promise<string | null>;
+    onRequestId?: (id: string | null) => void;
+}
+interface CommunityPost {
+    id: string;
+    title: string;
+    content: unknown;
+    categories?: string[];
+    thumbnail?: string;
+    viewCount?: number;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+interface Comment {
+    id: string;
+    body: string;
+    post?: string;
+    parent?: string;
+    rootComment?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+interface Reaction {
+    id: string;
+    post?: string;
+    comment?: string;
+    type?: string;
+    createdAt?: string;
+    [key: string]: unknown;
+}
+interface ReactionSummary {
+    counts: Record<string, number>;
+    total: number;
+    userReactions: string[];
+}
+interface Bookmark {
+    id: string;
+    post?: string;
+    createdAt?: string;
+    [key: string]: unknown;
+}
+interface ReactionType {
+    id: string;
+    title: string;
+    slug: string;
+    emoji?: string;
+    [key: string]: unknown;
+}
+interface PaginatedResponse<T> {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    totalPages: number;
+    page: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+}
+declare class CommunityClient {
+    private readonly publishableKey;
+    private readonly secretKey?;
+    private readonly customerToken?;
+    private readonly onUnauthorized?;
+    private readonly onRequestId?;
+    constructor(options: CommunityClientOptions);
+    private buildQuery;
+    private execute;
+    createPost(params: {
+        title: string;
+        content: unknown;
+        categories?: string[];
+        thumbnail?: string;
+    }): Promise<CommunityPost>;
+    getMyPosts(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<CommunityPost>>;
+    getTrending(params?: {
+        page?: number;
+        limit?: number;
+        period?: string;
+    }): Promise<PaginatedResponse<CommunityPost>>;
+    incrementView(params: {
+        postId: string;
+    }): Promise<{
+        viewCount: number;
+    }>;
+    reportPost(params: {
+        postId: string;
+        reason?: string;
+        reasonDetail?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    createComment(params: {
+        postId: string;
+        body: string;
+        parentId?: string;
+    }): Promise<Comment>;
+    listComments(params: {
+        postId: string;
+        page?: number;
+        limit?: number;
+        rootComment?: string;
+    }): Promise<PaginatedResponse<Comment>>;
+    updateComment(params: {
+        commentId: string;
+        body: string;
+    }): Promise<Comment>;
+    deleteComment(params: {
+        commentId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    reportComment(params: {
+        commentId: string;
+        reason?: string;
+        reasonDetail?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    addReaction(params: {
+        postId: string;
+        type: string;
+    }): Promise<Reaction>;
+    removeReaction(params: {
+        postId: string;
+        type: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    addCommentReaction(params: {
+        commentId: string;
+        type: string;
+    }): Promise<Reaction>;
+    removeCommentReaction(params: {
+        commentId: string;
+        type: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    getReactionSummary(params: {
+        postId: string;
+    }): Promise<ReactionSummary>;
+    getReactionTypes(): Promise<PaginatedResponse<ReactionType>>;
+    addBookmark(params: {
+        postId: string;
+    }): Promise<Bookmark>;
+    removeBookmark(params: {
+        postId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    getMyBookmarks(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<Bookmark>>;
+}
+
+interface ServerApiOptions {
+    publishableKey?: string;
+    secretKey: string;
+    onRequestId?: (id: string | null) => void;
+}
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+}
+declare abstract class BaseApi {
+    protected readonly publishableKey: string;
+    protected readonly secretKey: string;
+    protected readonly onRequestId?: (id: string | null) => void;
+    constructor(apiName: string, options: ServerApiOptions);
+    protected request<T>(endpoint: string, body: unknown, options?: RequestOptions): Promise<T>;
+}
+
+type ModerationApiOptions = ServerApiOptions;
+interface CommunityBan {
+    id: string;
+    customer: string;
+    isPermanent?: boolean;
+    bannedUntil?: string;
+    reason?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+type BanCustomerParams = {
+    customerId: string;
+    isPermanent?: boolean;
+    bannedUntil?: string;
+    reason?: string;
+};
+type UnbanCustomerParams = {
+    customerId: string;
+};
+declare class ModerationApi extends BaseApi {
+    constructor(options: ModerationApiOptions);
+    banCustomer(params: BanCustomerParams): Promise<CommunityBan>;
+    unbanCustomer(params: UnbanCustomerParams): Promise<{
+        success: true;
+    }>;
+}
+
+interface CustomerAuthResponse {
+    token: string;
+    customer: CustomerProfile;
+}
+interface MarketingConsentChannel {
+    isConsented?: boolean;
+}
+interface MarketingConsent {
+    email?: MarketingConsentChannel;
+    sms?: MarketingConsentChannel;
+    push?: MarketingConsentChannel;
+    consentSource?: string;
+}
+interface CustomerProfile {
+    id: string;
+    name: string;
+    email?: string | null;
+    phone?: string | null;
+    authProvider?: 'local' | 'google' | 'apple' | 'kakao' | 'naver' | null;
+    isGuest?: boolean | null;
+    marketingConsent?: MarketingConsent | null;
+    metadata?: Record<string, unknown> | null;
+    groups?: string[];
+}
+interface CustomerRegisterData {
+    name: string;
+    email: string;
+    password: string;
+    phone?: string;
+}
+interface CustomerRegisterResponse {
+    customer: CustomerProfile;
+}
+interface CustomerLoginData {
+    email: string;
+    password: string;
+}
+interface CustomerRefreshResponse {
+    token: string;
+}
+interface UpdateProfileData {
+    name?: string;
+    phone?: string;
+    marketingConsent?: MarketingConsent;
+}
+interface CustomerAuthOptions {
+    /**
+     * Persist token in localStorage. Defaults to `true`.
+     * - `true` (default): uses key `'customer-token'`
+     * - `string`: uses the given string as localStorage key
+     * - `false`: disables persistence (token/onTokenChange used instead)
+     *
+     * Handles SSR safely (no-op on server).
+     * When enabled, `token` and `onTokenChange` are ignored.
+     */
+    persist?: boolean | string;
+    /** Initial token (e.g. from SSR cookie) */
+    token?: string;
+    /** Called when token changes (login/logout) — use to persist in localStorage/cookie */
+    onTokenChange?: (token: string | null) => void;
+}
+
+/**
+ * Customer authentication client.
+ *
+ * Manages customer registration, login, logout, and token lifecycle.
+ * All requests include X-Publishable-Key for tenant resolution.
+ */
+declare class CustomerAuth {
+    private publishableKey;
+    private baseUrl;
+    private token;
+    private onTokenChange?;
+    private refreshPromise;
+    constructor(publishableKey: string, options?: CustomerAuthOptions);
+    /**
+     * Register a new customer account
+     */
+    register(data: CustomerRegisterData): Promise<CustomerRegisterResponse>;
+    /**
+     * Login with email and password. Stores the token internally.
+     */
+    login(data: CustomerLoginData): Promise<CustomerAuthResponse>;
+    /**
+     * Refresh the current token. Requires a valid (non-expired) token.
+     */
+    refreshToken(): Promise<CustomerRefreshResponse>;
+    private _doRefreshToken;
+    /**
+     * Clear the stored token
+     */
+    logout(): void;
+    /**
+     * Get the current authenticated customer's profile
+     */
+    me(): Promise<CustomerProfile | null>;
+    /**
+     * Request a password reset email
+     */
+    forgotPassword(email: string): Promise<void>;
+    /**
+     * Reset password using a token from the reset email
+     */
+    resetPassword(token: string, password: string): Promise<void>;
+    /**
+     * Update the authenticated customer's profile (name, phone, marketingConsent)
+     */
+    updateProfile(data: UpdateProfileData): Promise<CustomerProfile>;
+    /**
+     * Change the password of the currently authenticated customer
+     */
+    changePassword(currentPassword: string, newPassword: string): Promise<void>;
+    /**
+     * Get the authenticated customer's orders with pagination and optional status filter
+     */
+    getMyOrders(options?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+    }): Promise<PayloadFindResponse<Order>>;
+    /**
+     * Get the current token (or null if not authenticated)
+     */
+    getToken(): string | null;
+    /**
+     * Set the token manually (e.g. from SSR)
+     */
+    setToken(token: string | null): void;
+    /**
+     * Check if the customer is currently authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Internal: make a request with timeout and error handling.
+     * Auth endpoints don't retry — failures are final.
+     */
+    private requestJson;
+}
+
+interface CartApiOptions {
+    publishableKey?: string;
+    secretKey?: string;
+    customerToken?: string | (() => string | null);
+    onUnauthorized?: () => Promise<string | null>;
+    onRequestId?: (id: string | null) => void;
+}
+type AddItemParams = {
+    cartId: string;
+    product: string;
+    variant: string;
+    option: string;
+    quantity: number;
+};
+type UpdateItemParams = {
+    cartItemId: string;
+    quantity: number;
+};
+type RemoveItemParams = {
+    cartItemId: string;
+};
+type ApplyDiscountParams = {
+    cartId: string;
+    discountCode: string;
+};
+type RemoveDiscountParams = {
+    cartId: string;
+};
+type ClearCartParams = {
+    cartId: string;
+};
+declare class CartApi {
+    private readonly publishableKey;
+    private readonly secretKey?;
+    private readonly customerToken?;
+    private readonly onUnauthorized?;
+    private readonly onRequestId?;
+    constructor(options: CartApiOptions);
+    private execute;
+    getCart(cartId: string): Promise<Cart>;
+    addItem(params: AddItemParams): Promise<CartItem>;
+    updateItem(params: UpdateItemParams): Promise<CartItem>;
+    removeItem(params: RemoveItemParams): Promise<{
+        success: boolean;
+    }>;
+    applyDiscount(params: ApplyDiscountParams): Promise<Cart>;
+    removeDiscount(params: RemoveDiscountParams): Promise<Cart>;
+    clearCart(params: ClearCartParams): Promise<{
+        success: boolean;
+    }>;
+}
+
+type EntityID = string;
+type RelationshipValue = string | number | null | undefined | {
+    id?: string | number | null;
+};
+type MediaValue = {
+    id?: EntityID | null;
+} | EntityID | null | undefined;
+interface ProductOptionValueShape {
+    id?: string | number | null;
+    option?: RelationshipValue;
+    value?: string | null;
+    slug?: string | null;
+    _order?: string | null;
+    '_product-option-values_values_order'?: string | null;
+}
+interface ProductOptionShape {
+    id?: string | number | null;
+    title?: string | null;
+    _order?: string | null;
+    '_product-options_options_order'?: string | null;
+    values?: {
+        docs?: unknown[];
+    } | null;
+}
+interface ProductVariantShape {
+    id?: string | number | null;
+    optionValues?: unknown[] | null;
+    price?: number | null;
+    compareAtPrice?: number | null;
+    stock?: number | null;
+    isUnlimited?: boolean | null;
+    isActive?: boolean | null;
+    thumbnail?: MediaValue;
+    images?: MediaValue[] | null;
+    _order?: string | null;
+}
+interface ProductListingProductShape {
+    id?: EntityID;
+    thumbnail?: MediaValue;
+    images?: MediaValue[] | null;
+}
+type ProductOptionMatrixValue = {
+    id: string;
+    optionId: string;
+    label: string;
+    slug: string | null;
+    order: string;
+};
+type ProductOptionMatrixOption = {
+    id: string;
+    title: string;
+    order: string;
+    values: ProductOptionMatrixValue[];
+};
+type ProductOptionMatrixVariant<TVariant extends ProductVariantShape = ProductVariantShape> = {
+    id: string;
+    optionValueIds: string[];
+    optionValueByOptionId: Map<string, string>;
+    source: TVariant;
+};
+type ProductOptionMatrix<TVariant extends ProductVariantShape = ProductVariantShape> = {
+    options: ProductOptionMatrixOption[];
+    optionIds: string[];
+    optionById: Map<string, ProductOptionMatrixOption>;
+    valueById: Map<string, ProductOptionMatrixValue>;
+    valueToOptionId: Map<string, string>;
+    variants: ProductOptionMatrixVariant<TVariant>[];
+};
+type ProductListingProjection = {
+    selectionHintVariant: EntityID | null;
+    primaryImage: EntityID | null;
+    minPrice: number | null;
+    maxPrice: number | null;
+    minCompareAtPrice: number | null;
+    maxCompareAtPrice: number | null;
+    isPriceRange: boolean;
+    availableForSale: boolean;
+};
+type ProductListingGroup<TVariant extends ProductVariantShape = ProductVariantShape> = {
+    optionId: EntityID;
+    optionTitle: string;
+    optionValueId: EntityID;
+    optionValueLabel: string;
+    optionValueSlug: string | null;
+    variantIds: EntityID[];
+    variantCount: number;
+    variants: TVariant[];
+    listing: ProductListingProjection;
+};
+declare function buildProductOptionMatrix<TVariant extends ProductVariantShape = ProductVariantShape>({ options, variants, }: {
+    options: ProductOptionShape[];
+    variants?: TVariant[];
+}): ProductOptionMatrix<TVariant>;
+declare function getSelectedValueByOptionId<TVariant extends ProductVariantShape = ProductVariantShape>(matrix: ProductOptionMatrix<TVariant>, selectedValueIds: Iterable<unknown>): Map<string, string>;
+declare function normalizeSelectedValueIds<TVariant extends ProductVariantShape = ProductVariantShape>(matrix: ProductOptionMatrix<TVariant>, selectedValueIds: Iterable<unknown>): string[];
+declare function getAvailableOptionValues<TVariant extends ProductVariantShape = ProductVariantShape>(matrix: ProductOptionMatrix<TVariant>, optionId: string, selectedValueIds: Iterable<unknown>): ProductOptionMatrixValue[];
+declare function resolveVariantForSelection<TVariant extends ProductVariantShape = ProductVariantShape>(matrix: ProductOptionMatrix<TVariant>, selectedValueIds: Iterable<unknown>): ProductOptionMatrixVariant<TVariant> | undefined;
+declare function buildProductListingProjection(product: ProductListingProductShape | null | undefined, variants: ProductVariantShape[]): ProductListingProjection;
+declare function buildProductListingGroupsByOption<TVariant extends ProductVariantShape = ProductVariantShape>(args: {
+    product: ProductListingProductShape | null | undefined;
+    options: ProductOptionShape[];
+    variants: TVariant[];
+    primaryOptionId?: string | null;
+}): ProductListingGroup<TVariant>[];
+
+type ProductApiOptions = ServerApiOptions;
+type StockCheckParams = {
+    items: Array<{
+        variantId: string;
+        quantity: number;
+    }>;
+};
+type StockCheckResult = {
+    variantId: string;
+    available: boolean;
+    availableStock: number;
+    requestedQuantity: number;
+    error?: string;
+};
+type StockCheckResponse = {
+    results: StockCheckResult[];
+    allAvailable: boolean;
+};
+type ListingGroupsParams = {
+    productIds: string[];
+};
+type ProductListingGroupSummary = Omit<ProductListingGroup, 'variants'>;
+type ProductListingGroupsItem = {
+    product: Product;
+    primaryOptionId: string | null;
+    groups: ProductListingGroupSummary[];
+};
+type ProductListingGroupsResponse = {
+    docs: ProductListingGroupsItem[];
+};
+declare class ProductApi extends BaseApi {
+    constructor(options: ProductApiOptions);
+    /**
+     * Check point-in-time stock availability for one or more product variants.
+     * Results reflect available stock at the moment of the call and are not guaranteed
+     * to remain available by the time an order is placed.
+     */
+    stockCheck(params: StockCheckParams): Promise<StockCheckResponse>;
+    listingGroups(params: ListingGroupsParams): Promise<ProductListingGroupsResponse>;
+}
+
+type DiscountApiOptions = ServerApiOptions;
+type ValidateDiscountParams = {
+    code: string;
+    orderAmount: number;
+};
+type ValidateDiscountResult = {
+    valid: boolean;
+    code: string;
+    type?: 'percentage' | 'fixed_amount' | 'free_shipping' | 'tiered';
+    discountAmount: number;
+    freeShipping?: boolean;
+    reason?: string;
+};
+declare class DiscountApi extends BaseApi {
+    constructor(options: DiscountApiOptions);
+    validate(params: ValidateDiscountParams): Promise<ValidateDiscountResult>;
+}
+
+type ShippingApiOptions = ServerApiOptions;
+type CalculateShippingParams = {
+    shippingPolicyId?: string;
+    orderAmount: number;
+    postalCode?: string;
+};
+type CalculateShippingResult = {
+    shippingAmount: number;
+    baseShippingAmount: number;
+    extraShippingAmount: number;
+    freeShipping: boolean;
+    freeShippingMinAmount: number | null;
+    isJeju: boolean;
+    isRemoteIsland: boolean;
+};
+declare class ShippingApi extends BaseApi {
+    constructor(options: ShippingApiOptions);
+    calculate(params: CalculateShippingParams): Promise<CalculateShippingResult>;
+}
+
+type OrderApiOptions = ServerApiOptions;
+type CustomerSnapshot = {
+    name?: string;
+    email: string;
+    phone?: string;
+};
+type ReturnReason = 'change_of_mind' | 'defective' | 'wrong_delivery' | 'damaged' | 'other';
+type ReturnItem = {
+    orderItem: string;
+    quantity: number;
+};
+type CreateOrderParams = {
+    orderNumber: string;
+    customer?: string;
+    customerSnapshot: CustomerSnapshot;
+    shippingAddress: Order['shippingAddress'];
+    orderItems: Pick<OrderItem, 'product' | 'variant' | 'quantity' | 'unitPrice' | 'totalPrice'>[];
+    totalAmount: number;
+    shippingAmount?: number;
+    pgPaymentId?: string;
+    discountCode?: string;
+};
+type UpdateOrderParams = {
+    orderNumber: string;
+    status: Order['status'];
+};
+type TransactionStatus = 'pending' | 'paid' | 'failed' | 'canceled';
+type UpdateTransactionParams = {
+    pgPaymentId: string;
+    status: TransactionStatus;
+    paymentMethod?: string;
+    receiptUrl?: string;
+    paymentKey?: string;
+    amount?: number;
+};
+type RestockAction = 'return_to_stock' | 'discard';
+type ReturnWithRefundItem = {
+    orderItem: string | number;
+    quantity: number;
+    restockAction?: RestockAction;
+};
+type ReturnWithRefundParams = {
+    orderNumber: string;
+    reason?: ReturnReason;
+    reasonDetail?: string;
+    returnItems: ReturnWithRefundItem[];
+    refundAmount: number;
+    pgPaymentId: string;
+    paymentKey?: string;
+    refundReceiptUrl?: string;
+};
+type CheckoutParams = {
+    cartId: string;
+    orderNumber: string;
+    customerSnapshot: CustomerSnapshot;
+    pgPaymentId?: string;
+    discountCode?: string;
+};
+type CreateFulfillmentParams = {
+    orderNumber: string;
+    carrier?: string;
+    trackingNumber?: string;
+    items: Array<{
+        orderItem: string;
+        quantity: number;
+    }>;
+};
+type UpdateFulfillmentParams = {
+    fulfillmentId: string;
+    status: 'packed' | 'shipped' | 'delivered' | 'failed';
+    carrier?: string;
+    trackingNumber?: string;
+};
+type BulkImportFulfillmentsParams = {
+    items: Array<{
+        orderNumber: string;
+        carrier?: string;
+        trackingNumber?: string;
+    }>;
+};
+type BulkImportFulfillmentsResponse = {
+    succeeded: Array<{
+        orderNumber: string;
+        fulfillmentId: string;
+    }>;
+    failed: Array<{
+        orderNumber: string;
+        error: string;
+    }>;
+};
+type CreateReturnParams = {
+    orderNumber: string;
+    reason?: ReturnReason;
+    reasonDetail?: string;
+    returnItems: ReturnItem[];
+    refundAmount: number;
+};
+type UpdateReturnParams = {
+    returnId: string;
+    status: 'processing' | 'approved' | 'rejected' | 'completed';
+};
+declare class OrderApi extends BaseApi {
+    constructor(options: OrderApiOptions);
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    updateOrder(params: UpdateOrderParams): Promise<Order>;
+    updateTransaction(params: UpdateTransactionParams): Promise<Transaction>;
+    checkout(params: CheckoutParams): Promise<Order>;
+    createFulfillment(params: CreateFulfillmentParams): Promise<Fulfillment>;
+    updateFulfillment(params: UpdateFulfillmentParams): Promise<Fulfillment>;
+    bulkImportFulfillments(params: BulkImportFulfillmentsParams): Promise<BulkImportFulfillmentsResponse>;
+    returnWithRefund(params: ReturnWithRefundParams): Promise<{
+        return: Return;
+        transaction: Transaction | null;
+    }>;
+    createReturn(params: CreateReturnParams): Promise<Return>;
+    updateReturn(params: UpdateReturnParams): Promise<Return>;
+}
+
+interface ServerCommerceClientOptions {
+    publishableKey?: string;
+    secretKey: string;
+    onRequestId?: (id: string | null) => void;
+}
+declare class ServerCommerceClient {
+    readonly product: {
+        stockCheck: (params: StockCheckParams) => Promise<StockCheckResponse>;
+        listingGroups: (params: ListingGroupsParams) => Promise<ProductListingGroupsResponse>;
+    };
+    readonly cart: {
+        get: (cartId: string) => Promise<Cart>;
+        addItem: (params: AddItemParams) => Promise<CartItem>;
+        updateItem: (params: UpdateItemParams) => Promise<CartItem>;
+        removeItem: (params: RemoveItemParams) => Promise<{
+            success: boolean;
+        }>;
+        applyDiscount: (params: ApplyDiscountParams) => Promise<Cart>;
+        removeDiscount: (params: RemoveDiscountParams) => Promise<Cart>;
+        clear: (params: ClearCartParams) => Promise<{
+            success: boolean;
+        }>;
+    };
+    readonly orders: {
+        checkout: (params: CheckoutParams) => Promise<Order>;
+        create: (params: CreateOrderParams) => Promise<Order>;
+        update: (params: UpdateOrderParams) => Promise<Order>;
+        updateTransaction: (params: UpdateTransactionParams) => Promise<Transaction>;
+        createFulfillment: (params: CreateFulfillmentParams) => Promise<Fulfillment>;
+        updateFulfillment: (params: UpdateFulfillmentParams) => Promise<Fulfillment>;
+        bulkImportFulfillments: (params: BulkImportFulfillmentsParams) => Promise<BulkImportFulfillmentsResponse>;
+        createReturn: (params: CreateReturnParams) => Promise<Return>;
+        updateReturn: (params: UpdateReturnParams) => Promise<Return>;
+        returnWithRefund: (params: ReturnWithRefundParams) => Promise<{
+            return: Return;
+            transaction: Transaction | null;
+        }>;
+    };
+    readonly discounts: {
+        validate: (params: ValidateDiscountParams) => Promise<ValidateDiscountResult>;
+    };
+    readonly shipping: {
+        calculate: (params: CalculateShippingParams) => Promise<CalculateShippingResult>;
+    };
+    constructor(options: ServerCommerceClientOptions);
+}
+
+interface CollectionQueryParams<T extends PublicCollection> {
+    collection: T;
+    options?: ApiQueryOptions;
+}
+interface CollectionDetailQueryParams<T extends PublicCollection> {
+    collection: T;
+    id: string;
+    options?: ApiQueryOptions;
+}
+interface CollectionInfiniteQueryParams<T extends PublicCollection> {
+    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 {
+    protected queryClient: QueryClient;
+    protected collectionClient: CollectionClient;
+    constructor(queryClient: QueryClient, collectionClient: CollectionClient);
+    useQuery<T extends PublicCollection, 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 PublicCollection, TData = PayloadFindResponse<CollectionType<T>>>(params: CollectionQueryParams<T>, options?: SuspenseQueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseSuspenseQueryResult<TData, Error>;
+    useQueryById<T extends PublicCollection, TData = CollectionType<T>>(params: CollectionDetailQueryParams<T>, options?: QueryOptions<CollectionType<T>, TData>): _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<TData>, Error>;
+    useSuspenseQueryById<T extends PublicCollection, TData = CollectionType<T>>(params: CollectionDetailQueryParams<T>, options?: SuspenseQueryOptions<CollectionType<T>, TData>): _tanstack_react_query.UseSuspenseQueryResult<TData, Error>;
+    useInfiniteQuery<T extends PublicCollection, TData = InfiniteData<PayloadFindResponse<CollectionType<T>>>>(params: CollectionInfiniteQueryParams<T>, options?: InfiniteQueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseInfiniteQueryResult<TData, Error>;
+    useSuspenseInfiniteQuery<T extends PublicCollection, TData = InfiniteData<PayloadFindResponse<CollectionType<T>>>>(params: CollectionInfiniteQueryParams<T>, options?: SuspenseInfiniteQueryOptions<PayloadFindResponse<CollectionType<T>>, TData>): _tanstack_react_query.UseSuspenseInfiniteQueryResult<TData, Error>;
+    prefetchQuery<T extends PublicCollection>(params: CollectionQueryParams<T>, options?: {
+        staleTime?: number;
+    }): Promise<void>;
+    prefetchQueryById<T extends PublicCollection>(params: CollectionDetailQueryParams<T>, options?: {
+        staleTime?: number;
+    }): Promise<void>;
+    prefetchInfiniteQuery<T extends PublicCollection>(params: CollectionInfiniteQueryParams<T>, options?: {
+        pages?: number;
+        staleTime?: number;
+    }): Promise<void>;
+    useCreate<T extends PublicCollection>(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 PublicCollection>(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 PublicCollection>(params: {
+        collection: T;
+    }, options?: MutationCallbacks$1<CollectionType<T>>): _tanstack_react_query.UseMutationResult<CollectionType<T>, SDKError, string, unknown>;
+    invalidateQueries<T extends PublicCollection>(collection: T, type?: 'list' | 'detail' | 'infinite'): Promise<void>;
+    getQueryData<T extends PublicCollection>(collection: T, type: 'list', options?: ApiQueryOptions): PayloadFindResponse<CollectionType<T>> | undefined;
+    getQueryData<T extends PublicCollection>(collection: T, type: 'detail', id: string, options?: ApiQueryOptions): CollectionType<T> | null | undefined;
+    setQueryData<T extends PublicCollection>(collection: T, type: 'list', data: PayloadFindResponse<CollectionType<T>>, options?: ApiQueryOptions): void;
+    setQueryData<T extends PublicCollection>(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, 'useCreate' | 'useUpdate' | 'useRemove'>;
+/**
+ * Composes CollectionHooks + CustomerHooks into a single API surface.
+ * All methods are delegated; no logic lives here.
+ */
+declare class QueryHooks extends CollectionHooks {
+    private _customer;
+    constructor(queryClient: QueryClient, collectionClient: CollectionClient, customerAuth?: CustomerAuth);
+    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>): _tanstack_react_query.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>;
+}
+
+declare class ServerClient {
+    commerce: ServerCommerceClient;
+    community: CommunityClient & {
+        moderation: {
+            banCustomer: (p: BanCustomerParams) => Promise<CommunityBan>;
+            unbanCustomer: (p: UnbanCustomerParams) => Promise<{
+                success: true;
+            }>;
+        };
+    };
+    query: QueryHooks;
+    collections: CollectionClient;
+    queryClient: QueryClient;
+    lastRequestId: string | null;
+    protected state: ClientState;
+    protected config: ClientServerConfig;
+    constructor(options: ClientServerConfig);
+    getState(): ClientState;
+    getConfig(): Omit<ClientServerConfig, 'secretKey'>;
+}
+/**
+ * Create a server-only client with full read/write access. Requires secretKey.
+ * For read-only usage, prefer `createClient()` (no secretKey needed).
+ */
+declare function createServerClient(options: ClientServerConfig): ServerClient;
+
+export { isPermissionError as $, type AddItemParams as A, PermissionError as B, CustomerAuth as C, type DeepPartial as D, type ExtractArrayType as E, NotFoundError as F, GoneError as G, ConflictError as H, RateLimitError as I, isSDKError as J, isNetworkError as K, type ListingGroupsParams as L, isValidationError as M, NetworkError as N, isApiError as O, type ProductListingGroupsResponse as P, isConfigError as Q, type RemoveItemParams as R, type StockCheckParams as S, TimeoutError as T, type UpdateItemParams as U, type ValidateDiscountParams as V, isTimeoutError as W, isGoneError as X, isServiceUnavailableError as Y, isUsageLimitError as Z, isAuthError as _, type CustomerAuthOptions as a, type UpdateProfileData as a$, isNotFoundError as a0, isConflictError as a1, isRateLimitError as a2, createAuthError as a3, createPermissionError as a4, createNotFoundError as a5, createConflictError as a6, createRateLimitError as a7, createServerClient as a8, ServerClient as a9, type ShippingApiOptions as aA, CartApi as aB, type CartApiOptions as aC, ProductApi as aD, type ProductApiOptions as aE, type ProductListingGroupSummary as aF, type ProductListingGroupsItem as aG, type StockCheckResult as aH, CollectionQueryBuilder as aI, type ReadOnlyQueryBuilder as aJ, CollectionClient as aK, type GenerateMetadataOptions as aL, ServerCommerceClient as aM, type ServerCommerceClientOptions as aN, type CommunityClientOptions as aO, type CommunityPost as aP, ModerationApi as aQ, type ModerationApiOptions as aR, type CommunityBan as aS, type BanCustomerParams as aT, type UnbanCustomerParams as aU, type CustomerAuthResponse as aV, type CustomerRefreshResponse as aW, type CustomerRegisterResponse as aX, type CustomerProfile as aY, type CustomerRegisterData as aZ, type CustomerLoginData as a_, resolveApiUrl as aa, type ClientServerConfig as ab, type ClientMetadata as ac, type PaginationMeta as ad, type PayloadMutationResponse as ae, BaseApi as af, type ServerApiOptions as ag, type RequestOptions as ah, OrderApi as ai, type OrderApiOptions as aj, type CustomerSnapshot as ak, type ReturnReason as al, type ReturnItem as am, type CreateOrderParams as an, type UpdateOrderParams as ao, type BulkImportFulfillmentsParams as ap, type BulkImportFulfillmentsResponse as aq, type CreateReturnParams as ar, type UpdateReturnParams as as, type UpdateTransactionParams as at, type CreateFulfillmentParams as au, type ReturnWithRefundParams as av, type UpdateFulfillmentParams as aw, DiscountApi as ax, type DiscountApiOptions as ay, ShippingApi as az, type StockCheckResponse as b, type CollectionQueryParams as b0, type CollectionDetailQueryParams as b1, type CollectionInfiniteQueryParams as b2, type QueryOptions as b3, type SuspenseQueryOptions as b4, type InfiniteQueryOptions as b5, type SuspenseInfiniteQueryOptions as b6, CollectionHooks as b7, CustomerHooks as b8, QueryHooks as b9, type ProductOptionValueShape as ba, type ProductOptionShape as bb, type ProductVariantShape as bc, type ProductListingProductShape as bd, type ProductOptionMatrixValue as be, type ProductOptionMatrixOption as bf, type ProductOptionMatrixVariant as bg, type ProductOptionMatrix as bh, type ProductListingProjection as bi, type ProductListingGroup as bj, buildProductOptionMatrix as bk, getSelectedValueByOptionId as bl, normalizeSelectedValueIds as bm, getAvailableOptionValues as bn, resolveVariantForSelection as bo, buildProductListingProjection as bp, buildProductListingGroupsByOption as bq, type ApplyDiscountParams as c, type RemoveDiscountParams as d, type ClearCartParams as e, type CheckoutParams as f, type PayloadFindResponse as g, type ValidateDiscountResult as h, type CalculateShippingParams as i, type CalculateShippingResult as j, type ApiQueryOptions as k, type ProductListingGroupsQueryOptions as l, type ClientConfig as m, CommunityClient as n, type ReadOnlyQueryHooks as o, ReadOnlyCollectionClient as p, type ClientState as q, type DebugConfig as r, type RetryConfig as s, SDKError as t, ValidationError as u, ApiError as v, ConfigError as w, ServiceUnavailableError as x, UsageLimitError as y, AuthError as z };