@ethlete/query 5.15.0 → 5.16.0

package/lib/infinite-query/infinity-query.types.d.ts

@@ -1,104 +0,0 @@
-import { BaseArguments, WithHeaders } from '../query';
-import { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryDataOf } from '../query-creator';
-import { InfinityQuery } from './infinity-query';
-export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
-export type AppendItemsLocation = 'start' | 'end';
-export interface PageParamCalculatorOptions {
-    page: number;
-    totalPages: number | null;
-    itemsPerPage: number;
-}
-export interface TotalPagesExtractorOptions<Arguments extends BaseArguments | undefined, QueryResponse> {
-    response: QueryResponse;
-    itemsPerPage: number;
-    args: Arguments;
-}
-export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Arguments extends BaseArguments | undefined, QueryResponse, InfinityResponse extends unknown[]> {
-    /**
-     * The query creator to use for fetching pages.
-     */
-    queryCreator: QueryCreator;
-    /**
-     * The interval in milliseconds to poll on. If not provided, polling will be disabled.
-     * @default undefined
-     */
-    pollingInterval?: number;
-    /**
-     * The args that will be merged with the page arg.
-     */
-    defaultArgs?: Arguments & WithHeaders;
-    pageParam?: {
-        /**
-         * The location where the page param is in request.
-         *
-         * @default "query"
-         */
-        location?: InfinityQueryParamLocation;
-        /**
-         * Used as page param name.
-         *
-         * @default "page"
-         */
-        key?: string;
-        /**
-         * A function that calculates the page value for the next request.
-         * E.g. if the pagination is done with a `skip` param, the `pageParamName` should be `skip` and this function should return the correct value.
-         */
-        valueCalculator?: (data: PageParamCalculatorOptions) => number;
-    };
-    limitParam?: {
-        /**
-         * The location where the limit param is in request.
-         *
-         * @default "query"
-         */
-        location?: InfinityQueryParamLocation;
-        /**
-         * Used as limit param name.
-         *
-         * @default "limit"
-         */
-        key?: string;
-        /**
-         * The value of the limit param.
-         *
-         * @default 10
-         */
-        value?: number;
-    };
-    response: {
-        /**
-         * Determines if the response should get reversed before appending to the data array.
-         *
-         * @default false
-         */
-        reverse?: boolean;
-        /**
-         * Determines where to put the new items in the data array.
-         *
-         * @default "end"
-         */
-        appendItemsTo?: AppendItemsLocation;
-        /**
-         * The type of the array that will be created by the infinite query.
-         */
-        arrayType: InfinityResponse;
-        /**
-         * A function that returns the data array from the response.
-         * This function should return the type provided in `responseArrayType`.
-         */
-        valueExtractor?: (response: QueryResponse) => InfinityResponse;
-        /**
-         * The property in the response that contains the total page count.
-         *
-         * @default "totalPages"
-         */
-        totalPagesExtractor?: (data: TotalPagesExtractorOptions<QueryArgsOf<QueryCreator> & WithHeaders, QueryResponse>) => number;
-    };
-}
-type OmitUndefined<T> = T extends undefined ? never : T;
-export type AnyInfinityQueryConfig = InfinityQueryConfig<any, any, any, any>;
-export type AnyInfinityQuery = InfinityQuery<any, any, any, any, any>;
-export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryArgsOf<QueryCreator>>, QueryDataOf<QueryCreator>, InfinityResponse>;
-export type InfinityQueryOf<Cfg extends AnyInfinityQueryConfig | null> = InfinityQuery<NonNullable<Cfg>['queryCreator'], ConstructQuery<NonNullable<Cfg>['queryCreator']>, QueryArgsOf<NonNullable<Cfg>['queryCreator']>, QueryDataOf<NonNullable<Cfg>['queryCreator']>, NonNullable<Cfg>['response']['arrayType']>;
-export {};

package/lib/infinite-query/infinity-query.utils.d.ts

@@ -1,4 +0,0 @@
-import { AnyQueryCreator, QueryArgsOf, QueryDataOf } from '../query-creator';
-import { InfinityQueryConfig, PageParamCalculatorOptions } from './infinity-query.types';
-export declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
-export declare const skipPaginationPageParamCalculator: ({ page, itemsPerPage }: PageParamCalculatorOptions) => number;

package/lib/logger/logger.d.ts

@@ -1,12 +0,0 @@
-export declare const buildErrorMessage: (code: string, message: string) => string;
-export declare class QueryError extends Error {
-    data?: unknown;
-    constructor(code: string, message: string, data?: unknown);
-}
-export declare const invalidBaseRouteError: (data: unknown) => QueryError;
-export declare const invalidRouteError: (data: unknown) => QueryError;
-export declare const pathParamsMissingInRouteFunctionError: (data: unknown) => QueryError;
-export declare const queryStateAlreadyHasKeyError: (data: unknown) => QueryError;
-export declare const queryStateDoesNotContainKeyError: (data: unknown) => QueryError;
-export declare const queryStateCannotTransformError: (data: unknown) => QueryError;
-export declare const invalidBodyError: (data: unknown) => QueryError;

package/lib/query/query.d.ts

@@ -1,60 +0,0 @@
-import { Observable } from 'rxjs';
-import { EntityStore } from '../entity';
-import { QueryClient } from '../query-client';
-import { RequestError } from '../request';
-import { BaseArguments, ExecuteQueryOptions, GqlQueryConfig, PollConfig, QueryAutoRefreshConfig, QueryState, RestQueryConfig, RouteType } from './query.types';
-export declare class Query<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> {
-    private readonly _client;
-    readonly _id: number;
-    private _currentLocalId;
-    private _pollingSubscription;
-    private _onAbort$;
-    private _currentPollConfig;
-    private readonly _state$;
-    private get _nextId();
-    get state$(): Observable<QueryState<Data>>;
-    /**
-     * The current state of the query.
-     *
-     * **Warning!** This differs from the `state$` observable in that it does not use the query store. Thus, the response data might be outdated.
-     * Use `state$` (or `firstValueFrom(state$)`) the most up-to-date data.
-     */
-    get rawState(): QueryState<Response>;
-    get isExpired(): boolean;
-    get isInUse(): boolean;
-    get isPolling(): boolean;
-    get autoRefreshOnConfig(): Readonly<QueryAutoRefreshConfig>;
-    get store(): Store | null;
-    get canBeCached(): boolean;
-    get _isInMockMode(): boolean;
-    constructor(_client: QueryClient, 
-    /**
-     * @internal
-     */
-    _queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, 
-    /**
-     * @internal
-     */
-    _routeWithParams: Route, 
-    /**
-     * @internal
-     */
-    _arguments: Arguments, 
-    /**
-     * @internal
-     */
-    _queryStoreKey: string);
-    execute(options?: ExecuteQueryOptions): this;
-    abort(): this;
-    poll(config: PollConfig): this;
-    stopPolling(): this;
-    pausePolling(): this;
-    resumePolling(): this;
-    onSuccess(callback: (response: Data) => void): this;
-    onFailure(callback: (error: RequestError<unknown>) => void): this;
-    private _getBearerAuthProvider;
-    private _updateEntityState;
-    private _transformState;
-    private _updateState;
-    private _mockRequest;
-}

package/lib/query/query.types.d.ts

@@ -1,388 +0,0 @@
-import { Observable } from 'rxjs';
-import { EntityStore } from '../entity';
-import { AnyQueryCreator, ConstructQuery, QueryDataOf, QueryResponseOf } from '../query-creator';
-import { QueryForm } from '../query-form';
-import { Method, PathParams, QueryParams, RequestError, RequestProgress } from '../request';
-import { Query } from './query';
-export interface QueryAutoRefreshConfig {
-    /**
-     * Refresh the query when the query client's headers change.
-     * @default true
-     */
-    queryClientDefaultHeadersChange?: boolean;
-    /**
-     * Refresh the query when the window regains focus.
-     *
-     * This can only be disabled if `autoRefreshQueriesOnWindowFocus` is enabled on the query client.
-     * @default true
-     */
-    windowFocus?: boolean;
-}
-export interface EntitySetParams<Store, Response, Arguments, Id> {
-    /**
-     * The response data.
-     */
-    response: Response;
-    /**
-     * The id(s) returned by the `id` function.
-     */
-    id: Id;
-    /**
-     * The arguments passed to the query.
-     */
-    args: Arguments;
-    /**
-     * The entity store.
-     */
-    store: Store;
-}
-export interface EntityGetParams<Store, Response, Arguments, Id> {
-    /**
-     * The response data.
-     */
-    response: Response;
-    /**
-     * The id(s) returned by the `id` function.
-     */
-    id: Id;
-    /**
-     * The arguments passed to the query.
-     */
-    args: Arguments;
-    /**
-     * The entity store.
-     */
-    store: Store;
-}
-export interface EntityIdParams<Response, Arguments> {
-    /**
-     * The response data.
-     */
-    response: Response;
-    /**
-     * The arguments passed to the query.
-     */
-    args: Arguments;
-}
-export interface QueryEntityConfig<Store, Data, Response, Arguments, Id> {
-    /**
-     * The entity store to use for the query.
-     */
-    store: Store;
-    /**
-     * A function that returns the id of the entity. Can also return an array of ids.
-     */
-    id: (data: EntityIdParams<Response, Arguments>) => Id;
-    /**
-     * A function that returns the response data (can be a subset of the response).
-     */
-    get?: (data: EntityGetParams<Store, Response, Arguments, Id>) => Observable<Data>;
-    /**
-     * A function to update the entity store every time a new response is received.
-     */
-    set?: (data: EntitySetParams<Store, Response, Arguments, Id>) => void;
-}
-export type QueryConfigBase<Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = {
-    /**
-     * The http method to use for the query.
-     */
-    method: Method;
-    /**
-     * Determines if the auth provider should be used for this query.
-     * The query **will throw** if the query client's auth provider is unset.
-     */
-    secure?: boolean;
-    /**
-     * Determines if the query should emit progress events.
-     */
-    reportProgress?: boolean;
-    /**
-     * Determines the query's response type.
-     * @default 'json'
-     */
-    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
-    /**
-     * Whether this request should be sent with outgoing credentials (cookies).
-     * @default false
-     */
-    withCredentials?: boolean;
-    /**
-     * Configuration for handling auto refresh triggers.
-     *
-     * **Note:** This is only available for queries that can be refreshed. (`GET`, `HEAD`, `OPTIONS`, `GQL_QUERY`)
-     */
-    autoRefreshOn?: QueryAutoRefreshConfig;
-    /**
-     * Whether to automatically stop polling for this query when the window loses focus.
-     * Polling will resume when the window regains focus.
-     *
-     * This can only be disabled if `enableSmartPolling` is enabled on the query client.
-     * @default true
-     */
-    enableSmartPolling?: boolean;
-    /**
-     * Object containing the query's type information.
-     */
-    types?: {
-        /**
-         * The type of the successful response.
-         */
-        response?: Response;
-        /**
-         * Arguments for executing the query.
-         *
-         * - `pathParams`: The path parameters for the query. (in front of the ? in the url)
-         * - `queryParams`: The query parameters for the query. (after the ? in the url)
-         * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
-         * - `headers`: The headers for the query.
-         * - `variables`: The variables for the query. (graphql only)
-         */
-        args?: Arguments;
-    };
-    /**
-     * Object containing the query's entity store information.
-     */
-    entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id>;
-};
-export type RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = QueryConfigBase<Response, Arguments, Store, Data, Id> & {
-    /**
-     * The api route to use for the query.
-     */
-    route: Route;
-};
-export type GqlTransferOption = 'GET' | 'POST';
-export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> extends QueryConfigBase<Response, Arguments, Store, Data, Id> {
-    /**
-     * The graphql query to use for the query.
-     */
-    query: string;
-    /**
-     * Determines if the query should be sent via GET or POST.
-     * - `GET`: The query will be sent via query parameters.
-     * - `POST`: The query will be sent via the body.
-     * @default 'POST'
-     */
-    transferVia?: GqlTransferOption;
-    /**
-     * Subroute to use for the query.
-     */
-    route?: Route;
-}
-export type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any, any>;
-export type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any, any>;
-export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = Omit<RestQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;
-export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = Omit<GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;
-export type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams & WithMock<unknown>;
-export interface WithHeaders {
-    /**
-     * The headers to send with the query.
-     */
-    headers?: Record<string, string>;
-}
-export interface QueryMockConfig<MockResponse> {
-    /**
-     * The mock response to use for the query.
-     */
-    response?: MockResponse;
-    /**
-     * The mock error to use for the query.
-     */
-    error?: RequestError;
-    /**
-     * The delay in milliseconds to wait before resolving the mock.
-     * If progress is enabled, the delay will be used for each progress event.
-     * @default 200
-     */
-    delay?: number;
-    /**
-     * Whether to report progress for the mock.
-     * For testing e.g. file uploads.
-     */
-    progress?: {
-        /**
-         * The number of progress events to report.
-         * @default 5
-         */
-        eventCount?: number;
-        /**
-         * The type of progress event to report.
-         * @default 'upload'
-         */
-        eventType?: 'download' | 'upload';
-        /**
-         * The total size of the file to report progress for in bytes.
-         * @default 1_000_000 (1MB)
-         */
-        fileSize?: number;
-        /**
-         * If true, the total size of the file will be omitted from the progress event.
-         * Useful for testing e.g. download progress when the server does not provide a total size.
-         */
-        omitTotal?: boolean;
-        /**
-         * If true, the partial text will be omitted from the progress event.
-         * Useful for testing e.g. download progress when the server does not provide a partial text.
-         */
-        omitPartialText?: boolean;
-    };
-    /**
-     * This will mock the request failing and getting retried 3 times. After, the request will succeed with the provided response.
-     * Can not be used with `progress` enabled.
-     * @default false
-     */
-    retryIntoResponse?: boolean;
-}
-export interface WithMock<MockResponse> {
-    mock?: QueryMockConfig<MockResponse>;
-}
-export interface QueryConfig {
-    /**
-     * Whether this query should be added to the internal query store.
-     *
-     * Generally this should be left on `false` unless you know what you are doing.
-     * @default false
-     */
-    skipQueryStore?: boolean;
-    /**
-     * The cache key to use for this query.
-     * Useful for queries that are equal but should be stored separately.
-     * Will be generated automatically if not provided.
-     *
-     * Generally this should be left on `undefined` unless you know what you are doing.
-     */
-    queryStoreCacheKey?: string;
-}
-export interface WithConfig {
-    /**
-     * Additional configuration for this query.
-     */
-    config?: QueryConfig;
-}
-export interface WithVariables {
-    /**
-     * The variables for the query. (graphql only)
-     */
-    variables?: Record<string, unknown>;
-}
-export interface WithBody {
-    /**
-     * The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
-     */
-    body?: unknown;
-}
-export interface WithQueryParams {
-    /**
-     * The query parameters for the query. (after the ? in the url)
-     */
-    queryParams?: QueryParams;
-}
-export interface WithPathParams {
-    /**
-     * The path parameters for the query. (in front of the ? in the url)
-     */
-    pathParams?: PathParams;
-}
-export type QueryTrigger = 'program' | 'poll' | 'auto';
-export type EmptyObject = {};
-export interface ExecuteQueryOptions {
-    /**
-     * Whether to skip the cache for this query. This will force the query to be executed. It might still be caught by the native browser cache.
-     * @default false
-     */
-    skipCache?: boolean;
-    /**
-     * Whether to cancel the previous request if it is still loading.
-     * @default false
-     */
-    cancelPrevious?: boolean;
-}
-export type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
-    pathParams: infer PathParams;
-} ? (p: PathParams) => RouteString : RouteString;
-export type RouteString = `/${string}`;
-export type AnyRoute = ((p: PathParams) => string) | RouteString;
-export interface PollConfig {
-    /**
-     * The interval in milliseconds to poll the query.
-     */
-    interval: number;
-    /**
-     * A observable that will stop the polling when it emits.
-     */
-    takeUntil: Observable<unknown>;
-    /**
-     * Whether to trigger the query immediately after polling starts.
-     */
-    triggerImmediately?: boolean;
-}
-export declare const enum QueryStateType {
-    Prepared = "PREPARED",
-    Loading = "LOADING",
-    Success = "SUCCESS",
-    Failure = "FAILURE",
-    Cancelled = "CANCELLED"
-}
-export interface Prepared {
-    type: QueryStateType.Prepared;
-    meta: QueryStateMeta;
-}
-export interface Success<Response = unknown> {
-    type: QueryStateType.Success;
-    response: Response;
-    meta: QueryStateSuccessMeta;
-}
-export interface Failure {
-    type: QueryStateType.Failure;
-    error: RequestError;
-    meta: QueryStateMeta;
-}
-export interface Loading {
-    type: QueryStateType.Loading;
-    meta: QueryStateMeta;
-    partialText?: string;
-    progress?: RequestProgress;
-}
-export interface Cancelled {
-    type: QueryStateType.Cancelled;
-    meta: QueryStateMeta;
-}
-export interface QueryStateMeta {
-    id: number;
-    triggeredVia: QueryTrigger;
-    isWaitingForRetry?: boolean;
-    retryNumber?: number;
-    retryDelay?: number;
-}
-export interface QueryStateSuccessMeta extends QueryStateMeta {
-    expiresAt?: number;
-}
-export type QueryState<Response = unknown> = Loading | Success<Response> | Failure | Cancelled | Prepared;
-export type QueryStateResponseOf<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
-export type AnyQuery = Query<any, any, any, any, any, any>;
-export type AnyQueryCreatorCollection = {
-    [name: string]: AnyQueryCreator;
-};
-export type QueryCollectionOf<T extends {
-    [name: string]: AnyQueryCreator;
-}> = {
-    [K in keyof T]: {
-        type: K;
-        query: ConstructQuery<T[K]>;
-    };
-}[keyof T];
-export type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;
-export type QueryOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
-export type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;
-export type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;
-export type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQueryCollection ? T['type'] : never;
-export interface ResetPageOnErrorOperatorConfig<J extends QueryForm<any>> {
-    /**
-     * The query form to reset the page of.
-     */
-    queryForm: J;
-    /**
-     * The key of the page control in the query form.
-     * @default 'page'
-     */
-    pageControlKey?: string;
-}

package/lib/query/query.utils.d.ts

@@ -1,91 +0,0 @@
-import { Paginated } from '@ethlete/types';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { EntityStore } from '../entity';
-import { QueryClient } from '../query-client';
-import { AnyQueryCreator, QueryArgsOf, QueryCreator, QueryDataOf, QueryResponseOf, QueryStoreIdOf, QueryStoreOf } from '../query-creator';
-import { QueryForm } from '../query-form';
-import { Method, RequestHeaders, RequestHeadersMethodMap } from '../request';
-import { QueryContainerConfig } from '../utils';
-import { AnyGqlQueryConfig, AnyQuery, AnyQueryCollectionData, AnyQueryCreatorCollection, AnyRestQueryConfig, BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryCollectionOf, QueryState, QueryStateResponseOf, QueryStateType, ResetPageOnErrorOperatorConfig, RouteType, Success } from './query.types';
-type OmitNull<T> = T extends null ? never : T;
-export declare function filterSuccess(): <T extends QueryState | null, Response extends QueryStateResponseOf<OmitNull<T>>>(source: Observable<T>) => Observable<Success<Response>>;
-export declare function ignoreAutoRefresh(): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
-export declare function filterFailure(): <T extends QueryState | null>(source: Observable<T>) => Observable<Failure>;
-export declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
-export declare function takeUntilResponse(config?: {
-    excludeNull?: boolean;
-}): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
-export declare function filterNull(): <T>(source: Observable<T>) => Observable<OmitNull<T>>;
-export declare function switchQueryState(): <T extends AnyQuery | null, Data extends QueryDataOf<T>>(source: Observable<T>) => Observable<QueryState<Data> | null>;
-export declare function switchQueryCollectionState(): <T extends {
-    type: string;
-    query: import("@ethlete/query").Query<any, any, any, any, any, any>;
-} | null, Data extends AnyQueryCollectionData<OmitNull<T>>>(source: Observable<T>) => Observable<QueryState<Data> | null>;
-export declare const resetPageOnError: <T extends AnyQuery | null | undefined, J extends QueryForm<any>>(config: ResetPageOnErrorOperatorConfig<J>) => (source: Observable<T>) => Observable<QueryState<any> | T>;
-export declare const isQueryStateLoading: (state: QueryState | null | undefined) => state is Loading;
-export declare const isQueryStateSuccess: (state: QueryState | null | undefined) => state is Success<unknown>;
-export declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
-export declare const isQueryStateCancelled: (state: QueryState | null | undefined) => state is Cancelled;
-export declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
-export declare const isAutoRefresh: (state: QueryState | null | undefined) => boolean;
-export declare const mergeHeaders: (...headers: Array<RequestHeaders | null | undefined>) => RequestHeaders | null | undefined;
-export declare const isGqlQueryConfig: <Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, Store extends EntityStore<unknown>, Data, Id>(config: unknown) => config is GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>;
-export declare const isQuery: <T extends AnyQuery>(query: unknown) => query is T;
-export declare const isQueryCollection: <T extends {
-    type: string;
-    query: import("@ethlete/query").Query<any, any, any, any, any, any>;
-}>(query: unknown) => query is T;
-/**
- * @deprecated Use `createQueryCollectionSubject` instead. Will be removed in v6.
- */
-export declare const createQueryCollection: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T) => BehaviorSubject<R | null>;
-export declare const createQueryCollectionSubject: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => BehaviorSubject<R | null>;
-export declare const createQueryCollectionSignal: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => import("@angular/core").WritableSignal<R | null>;
-export declare const extractQuery: <T extends AnyQuery | {
-    type: string;
-    query: import("@ethlete/query").Query<any, any, any, any, any, any>;
-} | null>(v: T) => import("@ethlete/query").Query<any, any, any, any, any, any> | null;
-export declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
-export declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryArgsOf<QC>, Response extends QueryResponseOf<QC>, Store extends QueryStoreOf<QC>, Data extends QueryDataOf<QC>, Route extends RouteType<Arguments>, Id extends QueryStoreIdOf<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response | undefined>(config: {
-    creator: QC;
-    args?: OverrideArguments;
-    response?: OverrideResponse;
-}) => QueryCreator<OverrideArguments, OverrideResponse, Route, Store, Data, Id>;
-export declare const computeQueryMethod: (config: {
-    config: AnyRestQueryConfig | AnyGqlQueryConfig;
-    client: QueryClient;
-}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
-export declare const computeQueryBody: (config: {
-    config: AnyRestQueryConfig | AnyGqlQueryConfig;
-    client: QueryClient;
-    method: Method;
-    args?: BaseArguments;
-}) => unknown;
-export declare const computeQueryAuthHeader: (config: {
-    config: AnyRestQueryConfig | AnyGqlQueryConfig;
-    client: QueryClient;
-}) => Record<string, string> | null;
-export declare const computeQueryHeaders: (config: {
-    config: AnyRestQueryConfig | AnyGqlQueryConfig;
-    client: QueryClient;
-    args?: BaseArguments;
-}) => RequestHeaders | undefined;
-export declare const computeQueryQueryParams: (config: {
-    config: AnyRestQueryConfig | AnyGqlQueryConfig;
-    client: QueryClient;
-    args?: BaseArguments;
-}) => object | undefined;
-export declare const paginatedEntityValueUpdater: <T extends Paginated<unknown>, Args extends BaseArguments, Entity, J extends T extends Paginated<infer X> ? X : never>(findFn: (val: J, entity: Entity) => boolean) => ({ response, rawResponse, entity }: {
-    rawResponse: T;
-    response: T;
-    args: Args;
-    entity: Entity;
-}) => {
-    response: T & {
-        items: unknown[];
-    };
-    rawResponse: T & {
-        items: unknown[];
-    };
-} | null;
-export {};