import * as _tanstack_react_query from '@tanstack/react-query';
import { UseQueryOptions, QueryKey, UseMutationOptions, UseInfiniteQueryOptions } from '@tanstack/react-query';
import * as _tanstack_query_core from '@tanstack/query-core';
import { InfiniteData } from '@tanstack/query-core';
import { FetchError } from '@medusajs/js-sdk';
import { HttpTypes, PaginatedResponse, AdminSalesChannelResponse, AdminSalesChannelListResponse } from '@medusajs/types';
import * as React from 'react';
import { DataTableColumnDef, DataTableFilter, DataTableEmptyStateProps } from '@medusajs/ui';
import * as _tanstack_table_core from '@tanstack/table-core';

type TQueryKey<TKey, TListQuery = any, TDetailQuery = string> = {
    all: readonly [TKey];
    lists: () => readonly [...TQueryKey<TKey>["all"], "list"];
    list: (query?: TListQuery) => readonly [...ReturnType<TQueryKey<TKey>["lists"]>, {
        query: TListQuery;
    }];
    details: () => readonly [...TQueryKey<TKey>["all"], "detail"];
    detail: (id: TDetailQuery, query?: TListQuery) => readonly [
        ...ReturnType<TQueryKey<TKey>["details"]>,
        TDetailQuery,
        {
            query: TListQuery;
        }
    ];
};

declare const customersQueryKeys: TQueryKey<"customers", any, string>;
declare const useCustomer: (id: string, query?: Record<string, any>, options?: Omit<UseQueryOptions<{
    customer: HttpTypes.AdminCustomer;
}, FetchError, {
    customer: HttpTypes.AdminCustomer;
}, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        customer: HttpTypes.AdminCustomer;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        customer: HttpTypes.AdminCustomer;
    }>;
    customer?: HttpTypes.AdminCustomer | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        customer: HttpTypes.AdminCustomer;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        customer: HttpTypes.AdminCustomer;
    }>;
    customer?: HttpTypes.AdminCustomer | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        customer: HttpTypes.AdminCustomer;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        customer: HttpTypes.AdminCustomer;
    }>;
    customer?: HttpTypes.AdminCustomer | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        customer: HttpTypes.AdminCustomer;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        customer: HttpTypes.AdminCustomer;
    }>;
    customer?: HttpTypes.AdminCustomer | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        customer: HttpTypes.AdminCustomer;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        customer: HttpTypes.AdminCustomer;
    }>;
    customer?: HttpTypes.AdminCustomer | undefined;
};
declare const useCustomers: (query?: Record<string, any>, options?: Omit<UseQueryOptions<PaginatedResponse<{
    customers: HttpTypes.AdminCustomer[];
}>, FetchError, PaginatedResponse<{
    customers: HttpTypes.AdminCustomer[];
}>, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    customers?: HttpTypes.AdminCustomer[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    customers?: HttpTypes.AdminCustomer[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    customers?: HttpTypes.AdminCustomer[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    customers?: HttpTypes.AdminCustomer[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        customers: HttpTypes.AdminCustomer[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    customers?: HttpTypes.AdminCustomer[] | undefined;
};
declare const useListCustomerAddresses: (id: string, options?: UseQueryOptions<HttpTypes.AdminCustomerAddressListResponse, FetchError, HttpTypes.AdminCustomerAddressListResponse, QueryKey>) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    addresses?: HttpTypes.AdminCustomerAddress[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    addresses?: HttpTypes.AdminCustomerAddress[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    addresses?: HttpTypes.AdminCustomerAddress[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    addresses?: HttpTypes.AdminCustomerAddress[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    addresses?: HttpTypes.AdminCustomerAddress[] | undefined;
};
declare const useCustomerAddress: (id: string, addressId: string, options?: UseQueryOptions<HttpTypes.AdminCustomerAddressResponse, FetchError, HttpTypes.AdminCustomerAddressResponse, QueryKey>) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressResponse>;
    address?: HttpTypes.AdminCustomerAddress | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressResponse>;
    address?: HttpTypes.AdminCustomerAddress | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressResponse>;
    address?: HttpTypes.AdminCustomerAddress | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressResponse>;
    address?: HttpTypes.AdminCustomerAddress | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminCustomerAddressResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminCustomerAddressResponse>;
    address?: HttpTypes.AdminCustomerAddress | undefined;
};

declare const ordersQueryKeys: TQueryKey<"orders"> & {
    preview: (orderId: string) => any;
    changes: (orderId: string) => any;
    lineItems: (orderId: string, query?: any) => any;
    shippingOptions: (orderId: string) => any;
};
declare const useOrder: (id: string, query?: Record<string, any>, options?: Omit<UseQueryOptions<HttpTypes.AdminOrderResponse, FetchError, HttpTypes.AdminOrderResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderResponse>;
    order?: HttpTypes.AdminOrder | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderResponse>;
    order?: HttpTypes.AdminOrder | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderResponse>;
    order?: HttpTypes.AdminOrder | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderResponse>;
    order?: HttpTypes.AdminOrder | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderResponse>;
    order?: HttpTypes.AdminOrder | undefined;
};
declare const useUpdateOrder: (id: string, options?: UseMutationOptions<HttpTypes.AdminOrderResponse, FetchError, HttpTypes.AdminUpdateOrder>) => _tanstack_react_query.UseMutationResult<HttpTypes.AdminOrderResponse, FetchError, HttpTypes.AdminUpdateOrder, unknown>;
declare const useOrderPreview: (id: string, query?: HttpTypes.AdminOrderFilters, options?: Omit<UseQueryOptions<HttpTypes.AdminOrderPreviewResponse, FetchError, HttpTypes.AdminOrderPreviewResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderPreviewResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderPreviewResponse>;
    order?: HttpTypes.AdminOrderPreview | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderPreviewResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderPreviewResponse>;
    order?: HttpTypes.AdminOrderPreview | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderPreviewResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderPreviewResponse>;
    order?: HttpTypes.AdminOrderPreview | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderPreviewResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderPreviewResponse>;
    order?: HttpTypes.AdminOrderPreview | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderPreviewResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderPreviewResponse>;
    order?: HttpTypes.AdminOrderPreview | undefined;
};
declare const useOrderChanges: (id: string, query?: HttpTypes.AdminOrderChangesFilters, options?: Omit<UseQueryOptions<HttpTypes.AdminOrderChangesResponse, FetchError, HttpTypes.AdminOrderChangesResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderChangesResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderChangesResponse>;
    order_changes?: HttpTypes.AdminOrderChange[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderChangesResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderChangesResponse>;
    order_changes?: HttpTypes.AdminOrderChange[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderChangesResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderChangesResponse>;
    order_changes?: HttpTypes.AdminOrderChange[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderChangesResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderChangesResponse>;
    order_changes?: HttpTypes.AdminOrderChange[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminOrderChangesResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminOrderChangesResponse>;
    order_changes?: HttpTypes.AdminOrderChange[] | undefined;
};

declare const useRequestOrderEdit: (id: string, options?: UseMutationOptions<HttpTypes.AdminOrderEditPreviewResponse, FetchError, HttpTypes.AdminRequestOrderEdit>) => _tanstack_react_query.UseMutationResult<HttpTypes.AdminOrderEditPreviewResponse, FetchError, HttpTypes.AdminRequestOrderEdit, unknown>;

declare const productsQueryKeys: TQueryKey<"products", any, string>;
declare const variantsQueryKeys: TQueryKey<"product_variants", any, string>;
declare const useProductVariants: (productId: string, query?: HttpTypes.AdminProductVariantParams, options?: Omit<UseQueryOptions<HttpTypes.AdminProductVariantListResponse, FetchError, HttpTypes.AdminProductVariantListResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
};
declare const useUpdateProductVariantsBatch: (productId: string, options?: UseMutationOptions<any, FetchError, any>) => _tanstack_react_query.UseMutationResult<any, FetchError, any, unknown>;
declare const useDeleteVariantLazy: (productId: string, options?: UseMutationOptions<HttpTypes.AdminProductVariantDeleteResponse, FetchError, {
    variantId: string;
}>) => _tanstack_react_query.UseMutationResult<HttpTypes.AdminProductVariantDeleteResponse, FetchError, {
    variantId: string;
}, unknown>;
declare const useProduct: (id: string, query?: Record<string, any>, options?: Omit<UseQueryOptions<HttpTypes.AdminProductResponse, FetchError, HttpTypes.AdminProductResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductResponse>;
    product?: HttpTypes.AdminProduct | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductResponse>;
    product?: HttpTypes.AdminProduct | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductResponse>;
    product?: HttpTypes.AdminProduct | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductResponse>;
    product?: HttpTypes.AdminProduct | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductResponse>;
    product?: HttpTypes.AdminProduct | undefined;
};
declare const useProducts: (query?: HttpTypes.AdminProductListParams, options?: Omit<UseQueryOptions<HttpTypes.AdminProductListResponse, FetchError, HttpTypes.AdminProductListResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    products?: HttpTypes.AdminProduct[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    products?: HttpTypes.AdminProduct[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    products?: HttpTypes.AdminProduct[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    products?: HttpTypes.AdminProduct[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    products?: HttpTypes.AdminProduct[] | undefined;
};
declare const useCreateProduct: (options?: UseMutationOptions<HttpTypes.AdminProductResponse, FetchError, HttpTypes.AdminCreateProduct>) => _tanstack_react_query.UseMutationResult<HttpTypes.AdminProductResponse, FetchError, HttpTypes.AdminCreateProduct, unknown>;
declare const useUpdateProduct: (id: string, options?: UseMutationOptions<HttpTypes.AdminProductResponse, FetchError, HttpTypes.AdminUpdateProduct>) => _tanstack_react_query.UseMutationResult<HttpTypes.AdminProductResponse, FetchError, HttpTypes.AdminUpdateProduct, unknown>;
declare const useDeleteProduct: (id: string, options?: UseMutationOptions<HttpTypes.AdminProductDeleteResponse, FetchError, void>) => _tanstack_react_query.UseMutationResult<HttpTypes.AdminProductDeleteResponse, FetchError, void, unknown>;

declare const productVariantQueryKeys: TQueryKey<"product_variant", any, string>;
declare const useVariants: (query?: HttpTypes.AdminProductVariantParams, options?: Omit<UseQueryOptions<HttpTypes.AdminProductVariantListResponse, FetchError, HttpTypes.AdminProductVariantListResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminProductVariantListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminProductVariantListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    variants?: HttpTypes.AdminProductVariant[] | undefined;
};
declare const useInfiniteVariants: (query?: Omit<HttpTypes.AdminProductVariantParams, "offset" | "limit"> & {
    limit?: number;
}, options?: Omit<UseInfiniteQueryOptions<HttpTypes.AdminProductVariantListResponse, FetchError, InfiniteData<HttpTypes.AdminProductVariantListResponse, number>, HttpTypes.AdminProductVariantListResponse, QueryKey, number>, "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam">) => _tanstack_react_query.UseInfiniteQueryResult<InfiniteData<HttpTypes.AdminProductVariantListResponse, number>, FetchError>;

declare const promotionsQueryKeys: {
    listRules: (id: string | null, ruleType: string, query?: HttpTypes.AdminGetPromotionRuleParams) => (string | HttpTypes.AdminGetPromotionRuleParams | null | undefined)[];
    listRuleAttributes: (ruleType: string, promotionType?: string, applicationMethodTargetType?: string) => (string | undefined)[];
    listRuleValues: (ruleType: string, ruleValue: string, query: HttpTypes.AdminGetPromotionsRuleValueParams) => (string | HttpTypes.AdminGetPromotionsRuleValueParams)[];
    all: readonly ["promotions"];
    lists: () => readonly ["promotions", "list"];
    list: (query?: any) => readonly ["promotions", "list", {
        query: any;
    }];
    details: () => readonly ["promotions", "detail"];
    detail: (id: string, query?: any) => readonly ["promotions", "detail", string, {
        query: any;
    }];
};
declare const usePromotions: (query?: HttpTypes.AdminGetPromotionsParams, options?: Omit<UseQueryOptions<HttpTypes.AdminPromotionListResponse, FetchError, HttpTypes.AdminPromotionListResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPromotionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPromotionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    promotions?: HttpTypes.AdminPromotion[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPromotionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPromotionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    promotions?: HttpTypes.AdminPromotion[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPromotionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPromotionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    promotions?: HttpTypes.AdminPromotion[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPromotionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPromotionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    promotions?: HttpTypes.AdminPromotion[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPromotionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPromotionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    promotions?: HttpTypes.AdminPromotion[] | undefined;
};

declare const regionsQueryKeys: TQueryKey<"regions", any, string>;
declare const useRegion: (id: string, query?: Record<string, any>, options?: Omit<UseQueryOptions<{
    region: HttpTypes.AdminRegion;
}, FetchError, {
    region: HttpTypes.AdminRegion;
}, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        region: HttpTypes.AdminRegion;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        region: HttpTypes.AdminRegion;
    }>;
    region?: HttpTypes.AdminRegion | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        region: HttpTypes.AdminRegion;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        region: HttpTypes.AdminRegion;
    }>;
    region?: HttpTypes.AdminRegion | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        region: HttpTypes.AdminRegion;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        region: HttpTypes.AdminRegion;
    }>;
    region?: HttpTypes.AdminRegion | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        region: HttpTypes.AdminRegion;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        region: HttpTypes.AdminRegion;
    }>;
    region?: HttpTypes.AdminRegion | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
        region: HttpTypes.AdminRegion;
    }, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<{
        region: HttpTypes.AdminRegion;
    }>;
    region?: HttpTypes.AdminRegion | undefined;
};
declare const useRegions: (query?: Record<string, any>, options?: Omit<UseQueryOptions<PaginatedResponse<{
    regions: HttpTypes.AdminRegion[];
}>, FetchError, PaginatedResponse<{
    regions: HttpTypes.AdminRegion[];
}>, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    regions?: HttpTypes.AdminRegion[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    regions?: HttpTypes.AdminRegion[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    regions?: HttpTypes.AdminRegion[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    regions?: HttpTypes.AdminRegion[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.PaginatedResponse<{
        regions: HttpTypes.AdminRegion[];
    }>>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    regions?: HttpTypes.AdminRegion[] | undefined;
};

declare const salesChannelsQueryKeys: TQueryKey<"sales-channels", any, string>;
declare const useSalesChannel: (id: string, options?: Omit<UseQueryOptions<AdminSalesChannelResponse, FetchError, AdminSalesChannelResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelResponse>;
    sales_channel?: HttpTypes.AdminSalesChannel | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelResponse>;
    sales_channel?: HttpTypes.AdminSalesChannel | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelResponse>;
    sales_channel?: HttpTypes.AdminSalesChannel | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelResponse>;
    sales_channel?: HttpTypes.AdminSalesChannel | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelResponse>;
    sales_channel?: HttpTypes.AdminSalesChannel | undefined;
};
declare const useSalesChannels: (query?: HttpTypes.AdminSalesChannelListParams, options?: Omit<UseQueryOptions<AdminSalesChannelListResponse, FetchError, AdminSalesChannelListResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    sales_channels?: HttpTypes.AdminSalesChannel[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    sales_channels?: HttpTypes.AdminSalesChannel[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    sales_channels?: HttpTypes.AdminSalesChannel[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    sales_channels?: HttpTypes.AdminSalesChannel[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<AdminSalesChannelListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<AdminSalesChannelListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    sales_channels?: HttpTypes.AdminSalesChannel[] | undefined;
};
declare const useSalesChannelRemoveProducts: (id: string, options?: UseMutationOptions<AdminSalesChannelResponse, FetchError, HttpTypes.AdminBatchLink["remove"]>) => _tanstack_react_query.UseMutationResult<AdminSalesChannelResponse, FetchError, string[] | undefined, unknown>;
declare const useSalesChannelAddProducts: (id: string, options?: UseMutationOptions<AdminSalesChannelResponse, FetchError, HttpTypes.AdminBatchLink["add"]>) => _tanstack_react_query.UseMutationResult<AdminSalesChannelResponse, FetchError, string[] | undefined, unknown>;

declare const shippingOptionsQueryKeys: TQueryKey<"shipping_options", any, string>;
declare const useShippingOption: (id: string, query?: Record<string, any>, options?: Omit<UseQueryOptions<HttpTypes.AdminShippingOptionResponse, Error, HttpTypes.AdminShippingOptionResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionResponse, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionResponse>;
    shipping_option?: HttpTypes.AdminShippingOption | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionResponse, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionResponse>;
    shipping_option?: HttpTypes.AdminShippingOption | undefined;
} | {
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionResponse, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionResponse>;
    shipping_option?: HttpTypes.AdminShippingOption | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionResponse, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionResponse>;
    shipping_option?: HttpTypes.AdminShippingOption | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionResponse, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionResponse>;
    shipping_option?: HttpTypes.AdminShippingOption | undefined;
};
declare const useShippingOptions: (query?: HttpTypes.AdminShippingOptionListParams, options?: Omit<UseQueryOptions<HttpTypes.AdminShippingOptionListResponse, FetchError, HttpTypes.AdminShippingOptionListResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    shipping_options?: HttpTypes.AdminShippingOption[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    shipping_options?: HttpTypes.AdminShippingOption[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    shipping_options?: HttpTypes.AdminShippingOption[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    shipping_options?: HttpTypes.AdminShippingOption[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminShippingOptionListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminShippingOptionListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    shipping_options?: HttpTypes.AdminShippingOption[] | undefined;
};

declare const pricePreferencesQueryKeys: TQueryKey<"price-preferences", any, string>;
declare const usePricePreferences: (query?: HttpTypes.AdminPricePreferenceListParams, options?: Omit<UseQueryOptions<HttpTypes.AdminPricePreferenceListResponse, FetchError, HttpTypes.AdminPricePreferenceListResponse, QueryKey>, "queryKey" | "queryFn">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPricePreferenceListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPricePreferenceListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    price_preferences?: HttpTypes.AdminPricePreference[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPricePreferenceListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPricePreferenceListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    price_preferences?: HttpTypes.AdminPricePreference[] | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPricePreferenceListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPricePreferenceListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    price_preferences?: HttpTypes.AdminPricePreference[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPricePreferenceListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPricePreferenceListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    price_preferences?: HttpTypes.AdminPricePreference[] | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminPricePreferenceListResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminPricePreferenceListResponse>;
    limit?: number | undefined;
    offset?: number | undefined;
    count?: number | undefined;
    estimate_count?: number;
    price_preferences?: HttpTypes.AdminPricePreference[] | undefined;
};

declare const storeQueryKeys: TQueryKey<"store", any, string>;
declare const useStore: (query?: HttpTypes.SelectParams, options?: Omit<UseQueryOptions<HttpTypes.AdminStoreResponse, FetchError, HttpTypes.AdminStoreResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminStoreResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminStoreResponse>;
    store?: HttpTypes.AdminStore | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminStoreResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminStoreResponse>;
    store?: HttpTypes.AdminStore | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminStoreResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminStoreResponse>;
    store?: HttpTypes.AdminStore | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminStoreResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminStoreResponse>;
    store?: HttpTypes.AdminStore | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminStoreResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminStoreResponse>;
    store?: HttpTypes.AdminStore | undefined;
};

declare const useUser: (id: string, query?: HttpTypes.AdminUserParams, options?: Omit<UseQueryOptions<HttpTypes.AdminUserResponse, FetchError, HttpTypes.AdminUserResponse, QueryKey>, "queryFn" | "queryKey">) => {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminUserResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminUserResponse>;
    user?: HttpTypes.AdminUser | undefined;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminUserResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminUserResponse>;
    user?: HttpTypes.AdminUser | undefined;
} | {
    error: FetchError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminUserResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminUserResponse>;
    user?: HttpTypes.AdminUser | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminUserResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminUserResponse>;
    user?: HttpTypes.AdminUser | undefined;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FetchError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<HttpTypes.AdminUserResponse, FetchError>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<HttpTypes.AdminUserResponse>;
    user?: HttpTypes.AdminUser | undefined;
};

type ComboboxExternalData = {
    offset: number;
    limit: number;
    count: number;
};
type ComboboxQueryParams = {
    id?: string;
    q?: string;
    offset?: number;
    limit?: number;
};
declare const useComboboxData: <TResponse extends ComboboxExternalData, TParams extends ComboboxQueryParams, TOption extends {
    label: string;
    value: string;
} = {
    label: string;
    value: string;
}>({ queryKey, queryFn, getOptions, defaultValue, defaultValueKey, selectedValue, pageSize, enabled, }: {
    queryKey: QueryKey;
    queryFn: (params: TParams) => Promise<TResponse>;
    getOptions: (data: TResponse) => TOption[];
    defaultValueKey?: keyof TParams;
    defaultValue?: string | string[];
    selectedValue?: string;
    pageSize?: number;
    enabled?: boolean;
}) => {
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    fetchNextPage: (options?: _tanstack_query_core.FetchNextPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchPreviousPage: (options?: _tanstack_query_core.FetchPreviousPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchNextPageError: boolean;
    isFetchingNextPage: boolean;
    isFetchPreviousPageError: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<_tanstack_query_core.InfiniteData<TResponse, unknown>>;
    options: TOption[];
    searchValue: string;
    onSearchValueChange: React.Dispatch<React.SetStateAction<string>>;
    disabled: boolean;
} | {
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: true;
    status: "success";
    fetchNextPage: (options?: _tanstack_query_core.FetchNextPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchPreviousPage: (options?: _tanstack_query_core.FetchPreviousPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<_tanstack_query_core.InfiniteData<TResponse, unknown>>;
    options: TOption[];
    searchValue: string;
    onSearchValueChange: React.Dispatch<React.SetStateAction<string>>;
    disabled: boolean;
} | {
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    status: "error";
    fetchNextPage: (options?: _tanstack_query_core.FetchNextPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchPreviousPage: (options?: _tanstack_query_core.FetchPreviousPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<_tanstack_query_core.InfiniteData<TResponse, unknown>>;
    options: TOption[];
    searchValue: string;
    onSearchValueChange: React.Dispatch<React.SetStateAction<string>>;
    disabled: boolean;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    status: "pending";
    fetchNextPage: (options?: _tanstack_query_core.FetchNextPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchPreviousPage: (options?: _tanstack_query_core.FetchPreviousPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<_tanstack_query_core.InfiniteData<TResponse, unknown>>;
    options: TOption[];
    searchValue: string;
    onSearchValueChange: React.Dispatch<React.SetStateAction<string>>;
    disabled: boolean;
} | {
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    status: "pending";
    fetchNextPage: (options?: _tanstack_query_core.FetchNextPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchPreviousPage: (options?: _tanstack_query_core.FetchPreviousPageOptions) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.InfiniteData<TResponse, unknown>, Error>>;
    fetchStatus: _tanstack_query_core.FetchStatus;
    promise: Promise<_tanstack_query_core.InfiniteData<TResponse, unknown>>;
    options: TOption[];
    searchValue: string;
    onSearchValueChange: React.Dispatch<React.SetStateAction<string>>;
    disabled: boolean;
};

declare const useDate: () => {
    getFullDate: ({ date, includeTime, }: {
        date: string | Date;
        includeTime?: boolean;
    }) => string;
    getRelativeDate: (date: string | Date) => string;
};

/**
 * Hook for debouncing search input
 * @returns searchValue, onSearchValueChange, query
 */
declare const useDebouncedSearch: () => {
    searchValue: string;
    onSearchValueChange: React.Dispatch<React.SetStateAction<string>>;
    query: string | undefined;
};

type QueryParams<T extends string> = {
    [key in T]: string | undefined;
};
declare function useQueryParams<T extends string>(keys: T[], prefix?: string): QueryParams<T>;

type EntityWithDates = {
    created_at: string;
    updated_at: string;
};
declare const useDataTableDateColumns: <TData extends EntityWithDates>() => DataTableColumnDef<TData>[];

declare const useDataTableDateFilters: (disableRangeOption?: boolean) => DataTableFilter[];

declare const useSalesChannelTableColumns: () => ((_tanstack_table_core.AccessorKeyColumnDefBase<HttpTypes.AdminSalesChannel, string> & Partial<_tanstack_table_core.IdIdentifier<HttpTypes.AdminSalesChannel, string>>) | (_tanstack_table_core.AccessorKeyColumnDefBase<HttpTypes.AdminSalesChannel, boolean> & Partial<_tanstack_table_core.IdIdentifier<HttpTypes.AdminSalesChannel, boolean>>) | (_tanstack_table_core.ColumnDefBase<HttpTypes.AdminSalesChannel, unknown> & _tanstack_table_core.StringHeaderIdentifier) | (_tanstack_table_core.ColumnDefBase<HttpTypes.AdminSalesChannel, unknown> & _tanstack_table_core.IdIdentifier<HttpTypes.AdminSalesChannel, unknown>))[];

declare const useSalesChannelTableEmptyState: () => DataTableEmptyStateProps;

declare const useSalesChannelTableFilters: () => DataTableFilter[];

type UseSalesChannelTableQueryProps = {
    prefix?: string;
    pageSize?: number;
};
declare const useSalesChannelTableQuery: ({ prefix, pageSize, }: UseSalesChannelTableQueryProps) => HttpTypes.AdminSalesChannelListParams;

export { customersQueryKeys, ordersQueryKeys, pricePreferencesQueryKeys, productVariantQueryKeys, productsQueryKeys, promotionsQueryKeys, regionsQueryKeys, salesChannelsQueryKeys, shippingOptionsQueryKeys, storeQueryKeys, useComboboxData, useCreateProduct, useCustomer, useCustomerAddress, useCustomers, useDataTableDateColumns, useDataTableDateFilters, useDate, useDebouncedSearch, useDeleteProduct, useDeleteVariantLazy, useInfiniteVariants, useListCustomerAddresses, useOrder, useOrderChanges, useOrderPreview, usePricePreferences, useProduct, useProductVariants, useProducts, usePromotions, useQueryParams, useRegion, useRegions, useRequestOrderEdit, useSalesChannel, useSalesChannelAddProducts, useSalesChannelRemoveProducts, useSalesChannelTableColumns, useSalesChannelTableEmptyState, useSalesChannelTableFilters, useSalesChannelTableQuery, useSalesChannels, useShippingOption, useShippingOptions, useStore, useUpdateOrder, useUpdateProduct, useUpdateProductVariantsBatch, useUser, useVariants, variantsQueryKeys };