@openapi-qraft/react 1.10.1 → 1.11.0-beta.1

package/dist/cjs/index.d.cts

@@ -0,0 +1,1035 @@
+import * as react from 'react';
+import { Context, ReactNode } from 'react';
+import { QueryClient, UseMutationOptions, UseMutationResult, UndefinedInitialDataInfiniteOptions, UseInfiniteQueryResult, DefinedInitialDataInfiniteOptions, DefinedUseInfiniteQueryResult, UseQueryResult, UseQueryOptions, UndefinedInitialDataOptions, DefinedInitialDataOptions, DefinedUseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryResult, UseSuspenseQueryOptions, QueriesResults, SuspenseQueriesResults } from '@tanstack/react-query';
+import { InfiniteData, DefaultError, FetchStatus, Query, CancelOptions, QueryClient as QueryClient$1, QueryFunction, FetchQueryOptions, InitialPageParam, GetNextPageParamFunction, NoInfer, QueryState, InvalidateOptions, MutationState, Mutation, MutationStatus, ResetOptions, RefetchOptions, Updater, SetDataOptions, InfiniteQueryPageParamsOptions, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+
+/**
+ * This function is used to make a request to a specified endpoint.
+ *
+ * @template T The expected return type of the request.
+ *
+ * @param schema The schema of the operation to be performed. It includes the OpenAPI path, HTTP method and media type.
+ * @param requestInfo The information required to make the request. It includes parameters, headers, body, etc.
+ * @param [options] Optional. Additional options for the request. It includes custom urlSerializer, bodySerializer, and fetch function.
+ *
+ * @returns {Promise<T>} Returns a promise that resolves with the response of the request.
+ *
+ * @throws {error: object|string, response: Response} Throws an error if the request fails. The error includes the error message and the response from the server.
+ */
+declare function requestFn<T>(schema: OperationSchema, requestInfo: RequestFnInfo, options?: RequestFnOptions): Promise<T>;
+/**
+ * This function is used to make a request to a specified endpoint.
+ * It's needed to create a custom `requestFn` with a custom `urlSerializer`
+ * and `bodySerializer`, with the tree-shaking of the default `requestFn`
+ * and its serializers.
+ *
+ * @template T The expected return type of the request.
+ *
+ * @param requestSchema The schema of the operation to be performed. It includes the OpenAPI path, HTTP method and media type.
+ * @param requestInfo The information required to make the request. It includes parameters, headers, body, etc.
+ * @param options The options for the request. It includes urlSerializer, bodySerializer, and fetch function. The 'urlSerializer' and 'bodySerializer' are required.
+ *
+ * @returns {Promise<T>} Returns a promise that resolves with the response of the request.
+ *
+ * @throws {error: object|string, response: Response} Throws an error if the request fails. The error includes the error message and the response from the server.
+ */
+declare function baseRequestFn<T>(requestSchema: OperationSchema, requestInfo: RequestFnInfo, options: WithRequired<RequestFnOptions, 'urlSerializer' | 'bodySerializer'>): Promise<T>;
+declare function urlSerializer(schema: OperationSchema, info: RequestFnPayload): string;
+declare function mergeHeaders(...allHeaders: (HeadersOptions | undefined)[]): Headers;
+declare function bodySerializer(schema: OperationSchema, info: RequestFnPayload): string | Blob | FormData | undefined;
+type HeadersOptions = HeadersInit | Record<string, string | number | boolean | null | undefined>;
+interface OperationSchema {
+    /**
+     * Operation path
+     * @example /user/{id}
+     */
+    readonly url: string;
+    /**
+     * Operation method
+     */
+    readonly method: 'get' | 'put' | 'post' | 'patch' | 'delete' | 'options' | 'head' | 'trace';
+    /**
+     * Media type of the request body
+     * @example application/json
+     */
+    readonly mediaType?: string;
+    readonly security?: string[];
+}
+interface RequestFnPayload {
+    /**
+     * Base URL to use for the request
+     * @example 'https://api.example.com'
+     */
+    baseUrl: string | undefined;
+    /**
+     * OpenAPI parameters
+     * @example
+     * ```ts
+     * { path: {id: 1}, query: {search: 'hello'} }
+     * ```
+     */
+    readonly parameters?: {
+        readonly path?: Record<string, any>;
+        readonly header?: Record<string, any>;
+        readonly query?: Record<string, any>;
+    };
+    /**
+     * Request body
+     * @example { name: 'John' }
+     */
+    readonly body?: BodyInit | Record<string, unknown> | null;
+    /**
+     * Tanstack Query Meta
+     */
+    meta?: Record<string, unknown>;
+    /** An AbortSignal to set request's signal. */
+    signal?: AbortSignal | null;
+}
+interface RequestFnInfo extends RequestFnPayload, Omit<RequestInit, 'headers' | 'method' | 'body' | 'signal'> {
+    /**
+     * Request headers
+     * @example { 'X-Auth': '123' }
+     */
+    readonly headers?: HeadersOptions;
+}
+interface RequestFnOptions {
+    urlSerializer?: typeof urlSerializer;
+    bodySerializer?: typeof bodySerializer;
+    fetch?: typeof fetch;
+}
+type RequestFn$1<T> = typeof requestFn<T>;
+type WithRequired<T, K extends keyof T> = T & {
+    [_ in K]: {};
+};
+
+interface QraftContextValueBase {
+    /**
+     * Base URL to use for the request
+     * @example 'https://api.example.com'
+     */
+    baseUrl?: string;
+    /**
+     * The `requestFn` will be invoked with every request.
+     */
+    requestFn<T>(requestSchema: OperationSchema, requestInfo: RequestFnPayload): Promise<T>;
+    /** The QueryClient to use in Hooks */
+    queryClient?: QueryClient;
+}
+type QraftContextValue = QraftContextValueBase | undefined;
+declare const QraftContext: react.Context<QraftContextValue>;
+
+interface QraftClientOptions {
+    context?: Context<QraftContextValue>;
+}
+declare const qraftAPIClient: <Services extends ServicesBaseDeclaration<Services>, Callbacks extends ServicesCallbacks>(services: ServicesDeclaration<Services>, callbacks: Callbacks, options?: QraftClientOptions) => Services;
+type ServicesBaseDeclaration<Services> = {
+    [service in keyof Services]: {
+        [method in keyof Services[service]]: {
+            schema: OperationSchema;
+        };
+    };
+};
+type ServicesDeclaration<Services extends ServicesBaseDeclaration<Services>> = {
+    [service in keyof Services]: {
+        [method in keyof Services[service]]: {
+            schema: Services[service][method]['schema'];
+        };
+    };
+};
+type ServicesCallbacks = Record<string, (...rest: any[]) => unknown>;
+
+/**
+ * Shallow partial 'parameters'.
+ * @example
+ * ```ts
+ * {query?: {page: number, nested: {still: 'not_partial'}}}
+ * // =>
+ * {query?: {page?: number, nested?: {still: 'not_partial'}}}
+ * ```
+ */
+type PartialParameters<T> = T extends object ? {
+    [K in keyof T]?: T[K] extends object ? Partial<T[K]> : T[K];
+} : T;
+
+type OperationInfiniteData<TData, TParams> = InfiniteData<TData, PartialParameters<TParams>>;
+
+type ServiceOperationBaseQueryKey<S extends {
+    url: string;
+    method: string;
+}, Infinite extends boolean, T> = [S & {
+    infinite: Infinite;
+}, T];
+type ServiceOperationQueryKey<S extends {
+    url: string;
+    method: string;
+}, T> = ServiceOperationBaseQueryKey<S, false, T>;
+type ServiceOperationInfiniteQueryKey<S extends {
+    url: string;
+    method: string;
+}, T> = ServiceOperationBaseQueryKey<S, true, T>;
+type ServiceOperationMutationKey<S extends Record<'url' | 'method', string>, T> = NonNullable<T> extends never ? [S] : [S, T];
+
+type QueryTypeFilter = 'all' | 'active' | 'inactive';
+interface QueryFiltersBase<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> {
+    /**
+     * Include queries matching this predicate function
+     */
+    predicate?: TInfinite extends true ? QueryFilterInfinitePredicate<TSchema, TData, TParams, TError> : TInfinite extends false ? QueryFilterRegularPredicate<TSchema, TData, TParams, TError> : (query: string) => boolean;
+    /**
+     * Filter to active queries, inactive queries or all queries
+     */
+    type?: QueryTypeFilter;
+    /**
+     * Include or exclude stale queries
+     */
+    stale?: boolean;
+    /**
+     * Include queries matching their fetchStatus
+     */
+    fetchStatus?: FetchStatus;
+}
+interface QueryFiltersByQueryKeyBase<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> extends QueryFiltersBase<TSchema, TData, TInfinite, TParams, TError> {
+    infinite?: never;
+    parameters?: never;
+}
+interface QueryFiltersByExactQueryKey<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> extends QueryFiltersByQueryKeyBase<TSchema, TData, TInfinite, TParams, TError> {
+    /**
+     * Include queries matching this query key
+     */
+    queryKey: ServiceOperationBaseQueryKey<TSchema, TInfinite, TParams>;
+    /**
+     * Match query key exactly
+     */
+    exact: true;
+}
+interface QueryFiltersWeakExactQueryKey<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> extends QueryFiltersByQueryKeyBase<TSchema, TData, TInfinite, TParams, TError> {
+    /**
+     * Include queries matching this query key
+     */
+    queryKey?: ServiceOperationBaseQueryKey<TSchema, TInfinite, PartialParameters<TParams>>;
+    /**
+     * Match query key exactly
+     */
+    exact?: false;
+}
+type QueryFiltersByQueryKey<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> = QueryFiltersByExactQueryKey<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersWeakExactQueryKey<TSchema, TData, TInfinite, TParams, TError>;
+interface QueryFiltersByParametersBase<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> extends QueryFiltersBase<TSchema, TData, TInfinite, TParams, TError> {
+    /**
+     * Is the query infinite
+     */
+    infinite?: TInfinite;
+    queryKey?: never;
+}
+interface QueryFiltersByExactParameters<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> extends QueryFiltersByParametersBase<TSchema, TData, TInfinite, TParams, TError> {
+    /**
+     * Match query key exactly
+     */
+    exact: true;
+    /**
+     * Include queries matching parameters
+     */
+    parameters: TParams;
+}
+interface QueryFiltersByWeakParameters<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> extends QueryFiltersByParametersBase<TSchema, TData, TInfinite, TParams, TError> {
+    /**
+     * Match query key exactly
+     */
+    exact?: false;
+    /**
+     * Include queries matching parameters
+     */
+    parameters?: PartialParameters<TParams>;
+}
+type QueryFiltersByParameters<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> = QueryFiltersByExactParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByWeakParameters<TSchema, TData, TInfinite, TParams, TError>;
+interface QueryFilterInfinitePredicate<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    /**
+     * Include queries matching this predicate function
+     */
+    (query: Query<OperationInfiniteData<TData, TParams>, TError, OperationInfiniteData<TData, TParams>, ServiceOperationInfiniteQueryKey<TSchema, TParams>>): boolean;
+}
+interface QueryFilterRegularPredicate<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    /**
+     * Include queries matching this predicate function
+     */
+    (query: Query<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>): boolean;
+}
+
+interface ServiceOperationCancelQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    cancelQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, options: CancelOptions, queryClient: QueryClient$1): Promise<void>;
+    cancelQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): Promise<void>;
+    cancelQueries(queryClient: QueryClient$1): Promise<void>;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationCancelQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationCancelQueries<TSchema, TData, TParams, TError> {
+    cancelQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError> | QueryClient$1, options?: CancelOptions | QueryClient$1, queryClient?: QueryClient$1): Promise<void>;
+}
+
+interface ServiceOperationFetchInfiniteQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    fetchInfiniteQuery<TPageParam extends TParams>(options: (FetchInfiniteQueryOptionsByQueryKey<TSchema, TData, TParams, TPageParam, TError> & FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>) | (FetchInfiniteQueryOptionsByParameters<TSchema, TData, TParams, TPageParam, TError> & FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>), queryClient: QueryClient$1): Promise<OperationInfiniteData<TData, TParams>>;
+    prefetchInfiniteQuery<TPageParam extends TParams>(options: (FetchInfiniteQueryOptionsByQueryKey<TSchema, TData, TParams, TPageParam, TError> & FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>) | (FetchInfiniteQueryOptionsByParameters<TSchema, TData, TParams, TPageParam, TError> & FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>), queryClient: QueryClient$1): Promise<void>;
+}
+type FetchInfiniteQueryPages<TData = unknown, TPageParam = unknown> = {
+    pages?: never;
+} | {
+    pages: number;
+    getNextPageParam: GetNextPageParamFunction<PartialParameters<TPageParam>, TData>;
+};
+type FetchInfiniteQueryOptionsBase<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TPageParam = unknown, TError = DefaultError> = Omit<FetchQueryOptions<TData, TError, OperationInfiniteData<TData, TParams>, ServiceOperationQueryKey<TSchema, TParams>, TPageParam>, 'queryKey'> & InitialPageParam<PartialParameters<TPageParam>> & FetchInfiniteQueryPages<TData, TPageParam>;
+type FetchInfiniteQueryOptionsByQueryKey<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TPageParam = {}, TError = DefaultError> = FetchInfiniteQueryOptionsBase<TSchema, TData, TParams, TPageParam, TError> & {
+    /**
+     * Fetch Queries by query key
+     */
+    queryKey?: ServiceOperationInfiniteQueryKey<TSchema, TParams>;
+    parameters?: never;
+};
+type FetchInfiniteQueryOptionsByParameters<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TPageParam = {}, TError = DefaultError> = FetchInfiniteQueryOptionsBase<TSchema, TData, TParams, TPageParam, TError> & {
+    /**
+     * Fetch Queries by parameters
+     */
+    parameters?: TParams;
+    queryKey?: never;
+};
+type FetchInfiniteQueryOptionsQueryFn<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> = {
+    queryFn?: QueryFunction<TData, ServiceOperationInfiniteQueryKey<TSchema, TParams>>;
+} | {
+    requestFn: RequestFn$1<TData>;
+    /**
+     * Base URL to use for the request (used in the `queryFn`)
+     * @example 'https://api.example.com'
+     */
+    baseUrl: string | undefined;
+    queryFn?: never;
+};
+
+interface ServiceOperationFetchQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    fetchQuery(options: (FetchQueryOptionsByQueryKey<TSchema, TData, TParams, TError> & FetchQueryOptionsQueryFn<TSchema, TData, TParams>) | (FetchQueryOptionsByParameters<TSchema, TData, TParams, TError> & FetchQueryOptionsQueryFn<TSchema, TData, TParams>), queryClient: QueryClient$1): Promise<TData>;
+    prefetchQuery(options: (FetchQueryOptionsByQueryKey<TSchema, TData, TParams, TError> & FetchQueryOptionsQueryFn<TSchema, TData, TParams>) | (FetchQueryOptionsByParameters<TSchema, TData, TParams, TError> & FetchQueryOptionsQueryFn<TSchema, TData, TParams>), queryClient: QueryClient$1): Promise<void>;
+}
+type FetchQueryOptionsBase<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> = Omit<FetchQueryOptions<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>, 'queryKey' | 'queryFn'>;
+interface FetchQueryOptionsByQueryKey<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends FetchQueryOptionsBase<TSchema, TData, TParams, TError> {
+    /**
+     * Fetch Queries by query key
+     */
+    queryKey?: ServiceOperationQueryKey<TSchema, TParams>;
+}
+interface FetchQueryOptionsByParameters<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends FetchQueryOptionsBase<TSchema, TData, TParams, TError> {
+    /**
+     * Fetch Queries by parameters
+     */
+    parameters?: TParams;
+    queryKey?: never;
+}
+type FetchQueryOptionsQueryFn<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> = {
+    queryFn?: QueryFunction<TData, ServiceOperationQueryKey<TSchema, TParams>>;
+} | {
+    requestFn: RequestFn$1<TData>;
+    /**
+     * Base URL to use for the request (used in the `queryFn`)
+     * @example 'https://api.example.com'
+     */
+    baseUrl: string | undefined;
+    queryFn?: never;
+};
+
+interface ServiceOperationGetInfiniteQueryData<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> {
+    getInfiniteQueryData(parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>, queryClient: QueryClient$1): OperationInfiniteData<TData, TParams> | undefined;
+}
+
+interface ServiceOperationGetQueriesData<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, // todo::try to replace `TParams = {}` with `TParams = undefined`
+TError = DefaultError> {
+    getQueriesData<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): TInfinite extends true ? Array<[
+        queryKey: ServiceOperationInfiniteQueryKey<TSchema, TParams>,
+        data: NoInfer<OperationInfiniteData<TData, TParams>> | undefined
+    ]> : Array<[
+        queryKey: ServiceOperationQueryKey<TSchema, TParams>,
+        data: TData | undefined
+    ]>;
+}
+
+interface ServiceOperationGetQueryData<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> {
+    getQueryData(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, queryClient: QueryClient$1): TData | undefined;
+}
+
+interface ServiceOperationGetQueryState<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    getQueryState(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, queryClient: QueryClient$1): QueryState<TData, TError> | undefined;
+    getInfiniteQueryState(parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>, queryClient: QueryClient$1): QueryState<OperationInfiniteData<TData, TParams>, TError> | undefined;
+}
+
+type InvalidateQueryFilters<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TInfinite extends boolean, TParams = {}, TError = DefaultError> = (QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>) & {
+    refetchType?: QueryTypeFilter | 'none';
+};
+interface ServiceOperationInvalidateQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    invalidateQueries<TInfinite extends boolean>(filters: InvalidateQueryFilters<TSchema, TData, TInfinite, TParams, TError>, options: InvalidateOptions, queryClient: QueryClient$1): Promise<void>;
+    invalidateQueries<TInfinite extends boolean>(filters: InvalidateQueryFilters<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): Promise<void>;
+    invalidateQueries(queryClient: QueryClient$1): Promise<void>;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationInvalidateQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationInvalidateQueries<TSchema, TData, TParams, TError> {
+    invalidateQueries<TInfinite extends boolean>(filters: InvalidateQueryFilters<TSchema, TData, TInfinite, TParams, TError> | QueryClient$1, options?: InvalidateOptions | QueryClient$1, queryClient?: QueryClient$1): Promise<void>;
+}
+
+interface ServiceOperationIsFetchingQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    isFetching<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): number;
+    isFetching(queryClient: QueryClient$1): number;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationIsFetchingQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationIsFetchingQueries<TSchema, TData, TParams, TError> {
+    refetchQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError> | QueryClient$1, queryClient?: QueryClient$1): number;
+}
+
+interface ServiceOperationUseMutation<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams, TError = DefaultError> {
+    getMutationKey<TMutationKeyParams extends TParams | undefined = undefined>(parameters?: TMutationKeyParams): ServiceOperationMutationKey<TSchema, TMutationKeyParams>;
+    useMutation<TVariables extends MutationVariables<TBody, TParams>, TContext = unknown>(parameters?: undefined, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey'> & {
+        mutationKey?: ServiceOperationMutationKey<TSchema, TParams>;
+    }, queryClient?: QueryClient$1): UseMutationResult<TData, TError | Error, TVariables, TContext>;
+    useMutation<TVariables extends TBody, TContext = unknown>(parameters: TParams, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey'>, queryClient?: QueryClient$1): UseMutationResult<TData, TError | Error, TVariables, TContext>;
+}
+type MutationVariables<TBody, TParams> = {
+    body: TBody;
+} & (NonNullable<TParams> extends never ? {} : TParams);
+
+interface UseMutationStateFiltersBase<TBody, TData, TParams, TError = DefaultError, TContext = unknown> {
+    /**
+     * Match mutation key exactly
+     */
+    exact?: boolean;
+    /**
+     * Include mutations matching this predicate function
+     */
+    predicate?: (mutation: Mutation<TData, TError, MutationVariables<TBody, TParams>, TContext>) => boolean;
+    /**
+     * Filter by mutation status
+     */
+    status?: MutationStatus;
+}
+interface MutationFiltersByParameters<TBody, TData, TParams, TError = DefaultError, TContext = unknown> extends UseMutationStateFiltersBase<TBody, TData, TParams, TError, TContext> {
+    /**
+     * Include mutations matching these parameters
+     */
+    parameters?: PartialParameters<TParams>;
+    mutationKey?: never;
+}
+interface MutationFiltersByMutationKey<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams, TError = DefaultError, TContext = unknown> extends UseMutationStateFiltersBase<TBody, TData, TParams, TError, TContext> {
+    /**
+     * Include mutations matching this mutation key
+     */
+    mutationKey?: ServiceOperationMutationKey<TSchema, PartialParameters<TParams>>;
+    parameters?: never;
+}
+interface ServiceOperationUseMutationState<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams, TError = DefaultError> {
+    useMutationState<TContext = unknown, TResult = MutationState<TData, TError, MutationVariables<TBody, TParams>, TContext>>(options?: {
+        filters?: MutationFiltersByParameters<TBody, TData, TParams, TError, TContext> | MutationFiltersByMutationKey<TSchema, TBody, TData, TParams, TError, TContext>;
+        select?: (mutation: Mutation<TData, TError, MutationVariables<TBody, TParams>, TContext>) => TResult;
+    }, queryClient?: QueryClient$1): Array<TResult>;
+}
+
+interface ServiceOperationIsMutatingQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams = {}, TError = DefaultError> {
+    isMutating<TContext>(filters: MutationFiltersByParameters<TBody, TData, TParams, TError, TContext> | MutationFiltersByMutationKey<TSchema, TBody, TData, TParams, TError, TContext>, queryClient: QueryClient$1): number;
+    isMutating(queryClient: QueryClient$1): number;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationIsMutatingQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams = {}, TError = DefaultError> extends ServiceOperationIsMutatingQueries<TSchema, TBody, TData, TParams, TError> {
+    isMutating<TContext>(filters: MutationFiltersByParameters<TBody, TData, TParams, TError, TContext> | MutationFiltersByMutationKey<TSchema, TBody, TData, TParams, TError, TContext> | QueryClient$1, queryClient?: QueryClient$1): number;
+}
+
+interface QueryFnBaseUrlOptions$1 {
+    /**
+     * Base URL to use for the request
+     * @example 'https://api.example.com'
+     */
+    baseUrl: string;
+}
+interface ServiceOperationMutationFnOptionsBase<TBody, TParams> {
+    parameters: TParams;
+    body: TBody;
+}
+interface ServiceOperationMutationFnOptions<TBody, TParams> extends ServiceOperationMutationFnOptionsBase<TBody, TParams> {
+    baseUrl?: never;
+}
+interface ServiceOperationMutationFnOptionsWithBaseUrl<TBody, TParams> extends ServiceOperationMutationFnOptionsBase<TBody, TParams>, QueryFnBaseUrlOptions$1 {
+}
+interface ServiceOperationMutationFn<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams> {
+    /**
+     * @deprecated Use `<service>.<operation>(...)` instead.
+     */
+    mutationFn(client: (schema: TSchema, options: {
+        parameters: TParams;
+        body: TBody;
+    }) => TData, options: {
+        parameters: TParams;
+        body: TBody;
+    }): TData;
+    /**
+     * @deprecated Use `<service>.<operation>(...)` instead.
+     */
+    mutationFn(client: (schema: TSchema, options: {
+        parameters: TParams;
+        body: TBody;
+    }) => Promise<TData>, options: {
+        parameters: TParams;
+        body: TBody;
+    }): Promise<TData>;
+    <TOptions extends ServiceOperationMutationFnOptions<TBody, TParams>>(options: TOptions, client: (schema: TSchema, options: TOptions) => TData): TData;
+    <TOptions extends ServiceOperationMutationFnOptionsWithBaseUrl<TBody, TParams>>(options: TOptions, client: (schema: TSchema, options: TOptions) => TData): TData;
+    <TOptions extends ServiceOperationMutationFnOptions<TBody, TParams>>(options: TOptions, client: (schema: TSchema, options: TOptions) => Promise<TData>): Promise<TData>;
+    <TOptions extends ServiceOperationMutationFnOptionsWithBaseUrl<TBody, TParams>>(options: TOptions, client: (schema: TSchema, options: TOptions) => Promise<TData>): Promise<TData>;
+}
+
+interface QueryFnOptionsBase<TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal> {
+    signal?: TSignal;
+    meta?: TMeta;
+}
+interface QueryFnOptionsByParameters<TParams, TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal> extends QueryFnOptionsBase<TMeta, TSignal> {
+    parameters: TParams;
+    queryKey?: never;
+    baseUrl?: never;
+}
+interface QueryFnOptionsByParametersWithBaseUrl<TParams, TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal> extends QueryFnOptionsBase<TMeta, TSignal>, QueryFnBaseUrlOptions {
+    parameters: TParams;
+    queryKey?: never;
+}
+interface QueryFnOptionsByQueryKey<TSchema extends {
+    url: string;
+    method: string;
+}, TParams, TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal> extends QueryFnOptionsBase<TMeta, TSignal> {
+    queryKey: ServiceOperationQueryKey<TSchema, TParams>;
+    parameters?: never;
+    baseUrl?: never;
+}
+interface QueryFnOptionsByQueryKeyWithBaseUrl<TSchema extends {
+    url: string;
+    method: string;
+}, TParams, TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal> extends QueryFnOptionsBase<TMeta, TSignal>, QueryFnBaseUrlOptions {
+    queryKey: ServiceOperationQueryKey<TSchema, TParams>;
+    parameters?: never;
+}
+interface QueryFnBaseUrlOptions {
+    /**
+     * Base URL to use for the request
+     * @example 'https://api.example.com'
+     */
+    baseUrl: string;
+}
+interface ServiceOperationQueryFn<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams> {
+    /**
+     * @deprecated Use `<service>.<operation>(...)` instead.
+     */
+    queryFn<TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal>(options: QueryFnOptionsByParameters<TParams, TMeta, TSignal> | QueryFnOptionsByQueryKey<TSchema, TParams, TMeta, TSignal>, client: (schema: TSchema, options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+    }) => TData): TData;
+    /**
+     * @deprecated Use `<service>.<operation>(...)` instead.
+     */
+    queryFn<TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal>(options: QueryFnOptionsByParameters<TParams, TMeta, TSignal> | QueryFnOptionsByQueryKey<TSchema, TParams, TMeta, TSignal>, client: (schema: TSchema, options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+    }) => Promise<TData>): Promise<TData>;
+    <TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal>(options: QueryFnOptionsByParameters<TParams, TMeta, TSignal> | QueryFnOptionsByQueryKey<TSchema, TParams, TMeta, TSignal>, client: (schema: TSchema, options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+    }) => TData): TData;
+    <TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal>(options: QueryFnOptionsByParametersWithBaseUrl<TParams, TMeta, TSignal> | QueryFnOptionsByQueryKeyWithBaseUrl<TSchema, TParams, TMeta, TSignal>, client: (schema: TSchema, options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+    } & QueryFnBaseUrlOptions) => TData): TData;
+    <TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal>(options: QueryFnOptionsByParameters<TParams, TMeta, TSignal> | QueryFnOptionsByQueryKey<TSchema, TParams, TMeta, TSignal>, client: (schema: TSchema, options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+    }) => Promise<TData>): Promise<TData>;
+    <TMeta extends Record<string, any>, TSignal extends AbortSignal = AbortSignal>(options: QueryFnOptionsByParametersWithBaseUrl<TParams, TMeta, TSignal> | QueryFnOptionsByQueryKeyWithBaseUrl<TSchema, TParams, TMeta, TSignal>, client: (schema: TSchema, options: {
+        parameters: TParams;
+        signal?: TSignal;
+        meta?: TMeta;
+    } & QueryFnBaseUrlOptions) => Promise<TData>): Promise<TData>;
+}
+
+interface ServiceOperationResetQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    resetQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, options: ResetOptions, queryClient: QueryClient$1): Promise<void>;
+    resetQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): Promise<void>;
+    resetQueries(queryClient: QueryClient$1): Promise<void>;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationResetQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationResetQueries<TSchema, TData, TParams, TError> {
+    resetQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError> | QueryClient$1, options?: ResetOptions | QueryClient$1, queryClient?: QueryClient$1): Promise<void>;
+}
+
+interface ServiceOperationRefetchQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    refetchQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, options: RefetchOptions, queryClient: QueryClient$1): Promise<void>;
+    refetchQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): Promise<void>;
+    refetchQueries(queryClient: QueryClient$1): Promise<void>;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationRefetchQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationRefetchQueries<TSchema, TData, TParams, TError> {
+    refetchQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError> | QueryClient$1, options?: RefetchOptions | QueryClient$1, queryClient?: QueryClient$1): Promise<void>;
+}
+
+interface ServiceOperationRemoveQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    removeQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient: QueryClient$1): void;
+    removeQueries(queryClient: QueryClient$1): void;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationRemoveQueriesCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationRemoveQueries<TSchema, TData, TParams, TError> {
+    removeQueries<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError> | QueryClient$1, queryClient?: QueryClient$1): void;
+}
+
+interface ServiceOperationSetInfiniteQueryData<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> {
+    setInfiniteQueryData(parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>, updater: Updater<NoInfer<OperationInfiniteData<TData, TParams>> | undefined, NoInfer<OperationInfiniteData<TData, TParams>> | undefined>, queryClient: QueryClient$1, options?: SetDataOptions): OperationInfiniteData<TData, TParams> | undefined;
+}
+
+interface ServiceOperationSetQueriesData<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, // todo::try to replace `TParams = {}` with `TParams = undefined`
+TError = DefaultError> {
+    setQueriesData<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, options: SetDataOptions, queryClient: QueryClient$1): Array<TData | undefined>;
+    setQueriesData<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, queryClient: QueryClient$1): Array<TData | undefined>;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationSetQueriesDataCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> extends ServiceOperationSetQueriesData<TSchema, TData, TParams, TError> {
+    setQueriesData<TInfinite extends boolean>(filters: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, options: SetDataOptions | QueryClient$1, queryClient?: QueryClient$1): Array<TData | undefined>;
+}
+
+interface ServiceOperationSetQueryData<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> {
+    setQueryData(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, options: SetDataOptions, queryClient: QueryClient$1): TData | undefined;
+    setQueryData(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, queryClient: QueryClient$1): TData | undefined;
+}
+/**
+ * @internal
+ */
+interface ServiceOperationSetQueryDataCallback<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}> extends ServiceOperationSetQueryData<TSchema, TData, TParams> {
+    setQueryData(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>, options: SetDataOptions | QueryClient$1, queryClient?: QueryClient$1): TData | undefined;
+}
+
+interface ServiceOperationUseInfiniteQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    getInfiniteQueryKey<TQueryKeyParams extends TParams>(parameters: TQueryKeyParams): ServiceOperationInfiniteQueryKey<TSchema, TQueryKeyParams>;
+    useInfiniteQuery<TPageParam extends TParams>(parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>, options: Omit<UndefinedInitialDataInfiniteOptions<TData, TError, OperationInfiniteData<TData, TParams>, ServiceOperationInfiniteQueryKey<TSchema, TParams>, PartialParameters<TPageParam>>, 'queryKey' | 'getPreviousPageParam' | 'getNextPageParam' | 'initialPageParam'> & InfiniteQueryPageParamsOptions<TData, PartialParameters<TPageParam>>, queryClient?: QueryClient$1): UseInfiniteQueryResult<OperationInfiniteData<TData, TParams>, TError | Error>;
+    useInfiniteQuery<TPageParam extends TParams>(parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>, options: Omit<DefinedInitialDataInfiniteOptions<TData, TError, OperationInfiniteData<TData, TParams>, ServiceOperationInfiniteQueryKey<TSchema, TParams>, PartialParameters<TPageParam>>, 'queryKey' | 'getPreviousPageParam' | 'getNextPageParam' | 'initialPageParam'> & InfiniteQueryPageParamsOptions<TData, PartialParameters<TPageParam>>, queryClient?: QueryClient$1): DefinedUseInfiniteQueryResult<OperationInfiniteData<TData, TParams>, TError | Error>;
+}
+
+interface ServiceOperationUseIsFetchingQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    useIsFetching<TInfinite extends boolean>(filters?: QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError> | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>, queryClient?: QueryClient$1): number;
+}
+
+interface ServiceOperationUseIsMutating<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams, TError = DefaultError> {
+    useIsMutating<TContext = unknown>(filters?: MutationFiltersByParameters<TBody, TData, TParams, TError, TContext> | MutationFiltersByMutationKey<TSchema, TBody, TData, TParams, TError, TContext>, queryClient?: QueryClient$1): number;
+}
+
+interface ServiceOperationUseQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    useQueries<TCombinedResult = Array<UseQueryResult<TData, TError>>>(options: {
+        queries: ReadonlyArray<Omit<UseQueryOptions<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>, 'placeholderData' | 'suspense' | 'queryKey'> & {
+            placeholderData?: TData | QueriesPlaceholderDataFunction<TData>;
+        } & ({
+            parameters: TParams;
+            queryKey?: never;
+        } | {
+            queryKey: ServiceOperationQueryKey<TSchema, TParams>;
+        })>;
+        combine?: (results: Array<UseQueryResult<TData, TError>>) => TCombinedResult;
+    }, queryClient?: QueryClient$1): TCombinedResult;
+}
+
+interface ServiceOperationUseQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    getQueryKey<QueryKeyParams extends TParams | undefined = undefined>(parameters?: QueryKeyParams): ServiceOperationQueryKey<TSchema, QueryKeyParams>;
+    useQuery(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, options?: Omit<UndefinedInitialDataOptions<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>, 'queryKey'>, queryClient?: QueryClient$1): UseQueryResult<TData, TError | Error>;
+    useQuery(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, options: Omit<DefinedInitialDataOptions<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>, 'queryKey'>, queryClient?: QueryClient$1): DefinedUseQueryResult<TData, TError | Error>;
+}
+
+interface ServiceOperationUseSuspenseInfiniteQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    useSuspenseInfiniteQuery<TPageParam extends TParams>(parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>, options: Omit<UseSuspenseInfiniteQueryOptions<TData, TError, OperationInfiniteData<TData, TParams>, TData, ServiceOperationInfiniteQueryKey<TSchema, TParams>, PartialParameters<TPageParam>>, 'queryKey' | 'getPreviousPageParam' | 'getNextPageParam' | 'initialPageParam'> & InfiniteQueryPageParamsOptions<TData, PartialParameters<TPageParam>>, queryClient?: QueryClient$1): UseSuspenseInfiniteQueryResult<OperationInfiniteData<TData, TParams>, TError | Error>;
+}
+
+interface ServiceOperationUseSuspenseQueries<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    useSuspenseQueries<TCombinedResult = Array<UseSuspenseQueryResult<TData, TError>>>(options: {
+        queries: ReadonlyArray<Omit<UseSuspenseQueryOptions<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>, 'queryKey'> & ({
+            parameters: TParams;
+            queryKey?: never;
+        } | {
+            queryKey: ServiceOperationQueryKey<TSchema, TParams>;
+        })>;
+        combine?: (results: Array<UseSuspenseQueryResult<TData, TError>>) => TCombinedResult;
+    }, queryClient?: QueryClient$1): TCombinedResult;
+}
+
+interface ServiceOperationUseSuspenseQueryQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams = {}, TError = DefaultError> {
+    useSuspenseQuery(parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>, options?: Omit<UseSuspenseQueryOptions<TData, TError, TData, ServiceOperationQueryKey<TSchema, TParams>>, 'queryKey'>, queryClient?: QueryClient$1): UseSuspenseQueryResult<TData, TError | Error>;
+}
+
+interface ServiceOperationQuery<TSchema extends {
+    url: string;
+    method: string;
+}, TData, TParams, TError = DefaultError> extends ServiceOperationUseQuery<TSchema, TData, TParams, TError>, ServiceOperationUseQueries<TSchema, TData, TParams, TError>, ServiceOperationUseSuspenseQueries<TSchema, TData, TParams, TError>, ServiceOperationUseInfiniteQuery<TSchema, TData, TParams, TError>, ServiceOperationUseSuspenseQueryQuery<TSchema, TData, TParams, TError>, ServiceOperationUseSuspenseInfiniteQuery<TSchema, TData, TParams, TError>, ServiceOperationUseIsFetchingQueries<TSchema, TData, TParams, TError>, ServiceOperationQueryFn<TSchema, TData, TParams>, ServiceOperationFetchQuery<TSchema, TData, TParams, TError>, ServiceOperationFetchInfiniteQuery<TSchema, TData, TParams, TError>, ServiceOperationGetQueryData<TSchema, TData, TParams>, ServiceOperationGetQueryState<TSchema, TData, TParams, TError>, ServiceOperationGetQueriesData<TSchema, TData, TParams, TError>, ServiceOperationGetInfiniteQueryData<TSchema, TData, TParams>, ServiceOperationSetQueryData<TSchema, TData, TParams>, ServiceOperationSetQueriesData<TSchema, TData, TParams, TError>, ServiceOperationSetInfiniteQueryData<TSchema, TData, TParams>, ServiceOperationInvalidateQueries<TSchema, TData, TParams, TError>, ServiceOperationCancelQueries<TSchema, TData, TParams, TError>, ServiceOperationRemoveQueries<TSchema, TData, TParams, TError>, ServiceOperationResetQueries<TSchema, TData, TParams, TError>, ServiceOperationRefetchQueries<TSchema, TData, TParams, TError>, ServiceOperationIsFetchingQueries<TSchema, TData, TParams, TError> {
+    schema: TSchema;
+    types: {
+        parameters: TParams;
+        data: TData;
+        error: TError;
+    };
+}
+interface ServiceOperationMutation<TSchema extends {
+    url: string;
+    method: string;
+}, TBody, TData, TParams, TError = DefaultError> extends ServiceOperationUseMutation<TSchema, TBody, TData, TParams, TError>, ServiceOperationUseIsMutating<TSchema, TBody, TData, TParams, TError>, ServiceOperationUseMutationState<TSchema, TBody, TData, TParams, TError>, ServiceOperationIsMutatingQueries<TSchema, TBody, TData, TParams, TError>, ServiceOperationMutationFn<TSchema, TBody, TData, TParams> {
+    schema: TSchema;
+    types: {
+        parameters: TParams;
+        data: TData;
+        error: TError;
+        body: TBody;
+    };
+}
+
+declare function getInfiniteQueryData<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, TData>['getInfiniteQueryData']>): InfiniteData<TData> | undefined;
+
+declare const getInfiniteQueryKey: (qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['getInfiniteQueryKey']>) => ServiceOperationInfiniteQueryKey<OperationSchema, unknown>;
+
+declare const getMutationKey: (qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationMutation<OperationSchema, unknown, unknown, unknown>['getMutationKey']>) => [OperationSchema, unknown];
+
+declare function getQueryData<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, TData>['getQueryData']>): TData | undefined;
+
+declare function getQueriesData<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, TData>['getQueriesData']>): TData | undefined;
+
+declare const getQueryKey: (qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['getQueryKey']>) => ServiceOperationQueryKey<OperationSchema, unknown>;
+
+declare const mutationFn: (qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: unknown) => Promise<unknown>;
+
+declare const queryFn: <TSchema extends {
+    url: string;
+    method: 'get' | 'head' | 'options';
+}, TData, TParams>(qraftOptions: QraftClientOptions | undefined, schema: TSchema, args: Parameters<ServiceOperationQuery<TSchema, TData, TParams>['queryFn']>) => Promise<TData>;
+
+declare function setInfiniteQueryData<TData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, TData>['setInfiniteQueryData']>): InfiniteData<TData> | undefined;
+
+declare function setQueryData<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationSetQueryDataCallback<OperationSchema, unknown, TData>['setQueryData']>): TData | undefined;
+
+declare function setQueriesData<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationSetQueriesDataCallback<OperationSchema, unknown, TData>['setQueriesData']>): TData | undefined;
+
+declare const useInfiniteQuery: <TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['useInfiniteQuery']>) => UseInfiniteQueryResult<TData, TError>;
+
+declare const useMutation: <TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationMutation<OperationSchema, object | undefined, TVariables, TData>['useMutation']>) => UseMutationResult<TData, TError, TVariables, TContext>;
+
+declare const useQuery: <TData = unknown, TError = DefaultError>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['useQuery']>) => UseQueryResult<TData, TError>;
+
+declare const useSuspenseQuery: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['useSuspenseQuery']>) => UseQueryResult<TData, TError>;
+
+declare const useSuspenseInfiniteQuery: <TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['useSuspenseInfiniteQuery']>) => UseSuspenseInfiniteQueryResult<TData, TError>;
+
+declare const useMutationState: <TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationMutation<OperationSchema, object | undefined, TVariables, TData>['useMutationState']>) => UseMutationResult<TData, TError, TVariables, TContext>;
+
+declare const useIsMutating: <TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationMutation<OperationSchema, object | undefined, TVariables, TData>['useIsMutating']>) => UseMutationResult<TData, TError, TVariables, TContext>;
+
+declare const useQueries: (qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['useQueries']>) => QueriesResults<never>;
+
+declare const useSuspenseQueries: (qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, unknown>['useSuspenseQueries']>) => SuspenseQueriesResults<never>;
+
+declare function invalidateQueries<TData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationInvalidateQueriesCallback<OperationSchema, unknown, TData>['invalidateQueries']>): Promise<void>;
+
+declare function cancelQueries<TData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationCancelQueriesCallback<OperationSchema, unknown, TData>['cancelQueries']>): Promise<void>;
+
+declare function resetQueries<TData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationResetQueriesCallback<OperationSchema, unknown, TData>['resetQueries']>): Promise<void>;
+
+declare function removeQueries<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationRemoveQueriesCallback<OperationSchema, unknown, TData>['removeQueries']>): Promise<void>;
+
+declare function refetchQueries<TData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationRefetchQueriesCallback<OperationSchema, unknown, TData>['refetchQueries']>): Promise<void>;
+
+declare function isFetching<TData>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationIsFetchingQueriesCallback<OperationSchema, unknown, TData>['isFetching']>): Promise<void>;
+
+declare function isMutating<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationIsMutatingQueriesCallback<OperationSchema, unknown, TData>['isMutating']>): Promise<void>;
+
+declare const useIsFetching: <TVariables = unknown>(qraftOptions: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, object | undefined, TVariables, unknown>['useIsFetching']>) => number;
+
+declare const fetchQuery: <TSchema extends {
+    url: string;
+    method: 'get' | 'head' | 'options';
+}, TData, TParams>(_: QraftClientOptions | undefined, schema: TSchema, args: Parameters<ServiceOperationQuery<TSchema, TData, TParams>['fetchQuery']>) => Promise<TData>;
+
+declare const prefetchQuery: <TSchema extends {
+    url: string;
+    method: 'get' | 'head' | 'options';
+}, TData, TParams>(_: QraftClientOptions | undefined, schema: TSchema, args: Parameters<ServiceOperationQuery<TSchema, TData, TParams>['prefetchQuery']>) => Promise<TData>;
+
+declare const fetchInfiniteQuery: <TSchema extends {
+    url: string;
+    method: 'get' | 'head' | 'options';
+}, TData, TParams>(_: QraftClientOptions | undefined, schema: TSchema, args: Parameters<ServiceOperationQuery<TSchema, TData, TParams>['fetchInfiniteQuery']>) => Promise<TData>;
+
+declare const prefetchInfiniteQuery: <TSchema extends {
+    url: string;
+    method: 'get' | 'head' | 'options';
+}, TData, TParams>(_: QraftClientOptions | undefined, schema: TSchema, args: Parameters<ServiceOperationQuery<TSchema, TData, TParams>['prefetchInfiniteQuery']>) => Promise<TData>;
+
+declare function getQueryState<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, TData>['getQueryState']>): TData | undefined;
+
+declare function getInfiniteQueryState<TData>(_: QraftClientOptions | undefined, schema: OperationSchema, args: Parameters<ServiceOperationQuery<OperationSchema, unknown, TData>['getInfiniteQueryState']>): TData | undefined;
+
+/**
+ * Called when <service>.<operation>(...) is invoked.
+ */
+declare const operationInvokeFn: <TSchema extends OperationSchema, TBody, TData, TParams>(qraftOptions: QraftClientOptions | undefined, schema: TSchema, args: Parameters<ServiceOperationQueryFn<TSchema, TData, TParams>> | Parameters<ServiceOperationMutationFn<TSchema, TBody, TData, TParams>>) => Promise<TData>;
+
+interface QraftSecureRequestFnBaseProps {
+    requestFn<T>(schema: OperationSchema, requestInfo: RequestFnInfo, options?: RequestFnOptions): Promise<T>;
+    securitySchemes: SecuritySchemeHandlers<string>;
+}
+type RequestFn = QraftSecureRequestFnBaseProps['requestFn'];
+interface QraftSecureRequestFnProps extends QraftSecureRequestFnBaseProps {
+    children(secureRequestFn: QraftSecureRequestFnBaseProps['requestFn']): ReactNode;
+    queryClient?: QueryClient;
+}
+declare function QraftSecureRequestFn({ children, requestFn, securitySchemes, queryClient: inQueryClient, }: QraftSecureRequestFnProps): react.FunctionComponentElement<{
+    children?: ReactNode;
+}>;
+declare const useSecuritySchemeAuth: ({ securitySchemes, requestFn, queryClient, }: QraftSecureRequestFnBaseProps & {
+    queryClient: QueryClient;
+}) => RequestFn;
+/**
+ * Create a secure `requestFn` that manages security schemes.
+ * It will automatically fetch and refresh tokens when needed
+ * using QueryClient and the provided security schemes.
+ *
+ * @param securitySchemes OpenAPI security schemes.
+ * @param requestFn Qraft `requestFn`
+ * @param queryClient QueryClient instance.
+ */
+declare function createSecureRequestFn(securitySchemes: SecuritySchemeHandlers<string>, requestFn: RequestFn, queryClient: QueryClient): RequestFn;
+type SecurityScheme = SecuritySchemeBearer | SecuritySchemeBasic | SecuritySchemeAPIKey | SecuritySchemeCookie;
+type SecuritySchemeBearer = string /** JWT Bearer token. **/ | {
+    /** Refresh interval in milliseconds. */
+    refreshInterval: number;
+    /** Token to be used for authentication. */
+    token: string;
+};
+interface SecuritySchemeBasic {
+    /** Credentials to be used for authentication. */
+    credentials: string;
+    /** Refresh interval in milliseconds. */
+    refreshInterval: number;
+}
+type SecuritySchemeAPIKey = {
+    /** Where the secret should be placed. */
+    in: 'header' | 'query';
+    /** Name of the secret key. */
+    name: string;
+    /** Secret to be used for authentication. */
+    value: string;
+    /** Refresh interval in milliseconds. */
+    refreshInterval?: number;
+};
+type SecuritySchemeCookie = {
+    /** Where the secret should be placed. */
+    in: 'cookie';
+    /** Refresh interval in milliseconds. */
+    refreshInterval?: number;
+};
+/**
+ * Type definition for a handler function that manages security schemes.
+ * This function is invoked when a token needs to be fetched or refreshed.
+ *
+ * @param props - The properties for the handler function.
+ * @param props.isRefreshing - A boolean indicating the state of the token.
+ *    It's `false` on the initial "fetch token" request, and `true` if the token is stale or updating using `refreshInterval`.
+ * @param props.signal - An AbortSignal that can be used to abort the request.
+ *
+ * @returns A SecurityScheme, which contains the necessary data for authentication.
+ */
+type SecuritySchemeHandler = (props: {
+    isRefreshing: boolean;
+    signal: AbortSignal;
+}) => SecurityScheme | Promise<SecurityScheme>;
+type SecuritySchemeHandlers<SecuritySchemeName extends string> = {
+    [key in SecuritySchemeName]: SecuritySchemeHandler;
+};
+
+export { type HeadersOptions, type OperationSchema, type QraftClientOptions, QraftContext, type QraftContextValue, type QraftSecureRequestFnProps, type RequestFn$1 as RequestFn, type RequestFnOptions, type RequestFnPayload, type SecuritySchemeAPIKey, type SecuritySchemeBasic, type SecuritySchemeBearer, type SecuritySchemeCookie, type SecuritySchemeHandlers, type ServiceOperationMutation, type ServiceOperationQuery, QraftSecureRequestFn as Unstable_QraftSecureRequestFn, baseRequestFn, bodySerializer, cancelQueries, createSecureRequestFn, fetchInfiniteQuery, fetchQuery, getInfiniteQueryData, getInfiniteQueryKey, getInfiniteQueryState, getMutationKey, getQueriesData, getQueryData, getQueryKey, getQueryState, invalidateQueries, isFetching, isMutating, mergeHeaders, mutationFn, operationInvokeFn, prefetchInfiniteQuery, prefetchQuery, qraftAPIClient, queryFn, refetchQueries, removeQueries, requestFn, resetQueries, setInfiniteQueryData, setQueriesData, setQueryData, urlSerializer, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useMutationState, useQueries, useQuery, useSecuritySchemeAuth, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };