@01.software/sdk 0.21.0 → 0.23.0

package/dist/server-D7FcHj7J.d.ts

@@ -0,0 +1,1420 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient, InfiniteData } from '@tanstack/react-query';
+import { O as Order, d as Cart, e as CartItem, f as Product, l as OrderItem, m as Transaction, n as Fulfillment, o as Return } from './payload-types-D8-G1PiT.js';
+import { Sort, Where } from 'payload';
+import { Metadata } from 'next';
+import { C as CollectionType } from './types-BQqfXbB2.js';
+import { P as PublicCollection, S as ServerCollection } from './const-CMdmNgEs.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<TCollection extends string = PublicCollection> extends HttpClient {
+    from<T extends TCollection>(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 ServerCollectionClient extends CollectionClient<ServerCollection> {
+    from<T extends ServerCollection>(collection: T): ServerCollectionQueryBuilder<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 string> {
+    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>>>;
+}
+declare class ServerCollectionQueryBuilder<T extends ServerCollection> extends CollectionQueryBuilder<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 | null;
+    displayTitle?: string | null;
+    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 | null;
+        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;
+    swatchColor?: string | null;
+    thumbnail?: MediaValue;
+    images?: MediaValue[] | 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;
+    reservedStock?: 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;
+    swatchColor?: string | null;
+    thumbnail?: MediaValue;
+    images?: MediaValue[] | 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;
+    optionValueSwatchColor?: string | null;
+    optionValueThumbnail?: MediaValue;
+    optionValueImages?: MediaValue[] | 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;
+/**
+ * Builds product-first listing groups for one primary option.
+ *
+ * The returned groups are intended for product cards with nested swatches or
+ * option-value sections. They do not make a product-paginated API response into
+ * an expanded-card paginator; one product can still emit several groups.
+ */
+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: ServerCollectionClient;
+    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 CustomerRegisterData 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, ServerCollectionQueryBuilder as aJ, type ReadOnlyQueryBuilder as aK, CollectionClient as aL, ServerCollectionClient as aM, type GenerateMetadataOptions as aN, ServerCommerceClient as aO, type ServerCommerceClientOptions as aP, type CommunityClientOptions as aQ, type CommunityPost as aR, ModerationApi as aS, type ModerationApiOptions as aT, type CommunityBan as aU, type BanCustomerParams as aV, type UnbanCustomerParams as aW, type CustomerAuthResponse as aX, type CustomerRefreshResponse as aY, type CustomerRegisterResponse as aZ, type CustomerProfile 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 CustomerLoginData as b0, type UpdateProfileData as b1, type CollectionQueryParams as b2, type CollectionDetailQueryParams as b3, type CollectionInfiniteQueryParams as b4, type QueryOptions as b5, type SuspenseQueryOptions as b6, type InfiniteQueryOptions as b7, type SuspenseInfiniteQueryOptions as b8, CollectionHooks as b9, CustomerHooks as ba, QueryHooks as bb, type ProductOptionValueShape as bc, type ProductOptionShape as bd, type ProductVariantShape as be, type ProductListingProductShape as bf, type ProductOptionMatrixValue as bg, type ProductOptionMatrixOption as bh, type ProductOptionMatrixVariant as bi, type ProductOptionMatrix as bj, type ProductListingProjection as bk, type ProductListingGroup as bl, buildProductOptionMatrix as bm, getSelectedValueByOptionId as bn, normalizeSelectedValueIds as bo, getAvailableOptionValues as bp, resolveVariantForSelection as bq, buildProductListingProjection as br, buildProductListingGroupsByOption as bs, 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 };