@ethlete/query 0.1.0-next.10 → 0.1.0-next.11

package/lib/auth/auth-provider.types.d.ts

@@ -63,6 +63,16 @@ export interface BearerRefreshConfig {
      * The api's refresh route method
      */
     method: Method;
+    /**
+     * The way the refresh token is sent to the api
+     * @default 'body'
+     */
+    paramLocation?: 'body' | 'query';
+    /**
+     * The time in milliseconds before the token expires when the refresh should be triggered.
+     * @default 300000 (5 minutes)
+     */
+    refreshBuffer?: number;
     /**
      * The expires in property name inside the jwt body
      * @default 'exp'
@@ -77,7 +87,7 @@ export interface BearerRefreshConfig {
      * Adapter function used to build the request body for the refresh request.
      * @default { refreshToken: "refreshToken" }
      */
-    bodyAdapter?: (refreshToken: string) => unknown;
+    requestAdapter?: (refreshToken: string) => Record<string, string>;
     /**
      * Adapter function used to extract the token and refreshToken from the response.
      * @default { token: "token", refreshToken: "refreshToken" }

package/lib/directives/infinity-query.directive.d.ts

@@ -4,7 +4,6 @@ import { BaseArguments } from '../query';
 import { AnyQueryCreator } from '../query-client';
 import { RequestError } from '../request';
 import * as i0 from "@angular/core";
-import * as i1 from "@ethlete/core";
 interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments, any, unknown[]>> {
     $implicit: Q['response']['arrayType'] | null;
     infinityQuery: Q['response']['arrayType'] | null;
@@ -44,6 +43,6 @@ export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQue
     private _renderMainView;
     private _cleanup;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", ["infinityQuery"], { "infinityQuery": "infinityQuery"; }, {}, never, never, true, [{ directive: typeof i1.DestroyDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", ["infinityQuery"], { "infinityQuery": "infinityQuery"; }, {}, never, never, true, never>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { BaseArguments, QueryStateData } from '../query';
 import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
-export declare type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
-export declare type AppendItemsLocation = 'start' | 'end';
+export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
+export type AppendItemsLocation = 'start' | 'end';
 export interface PageParamCalculatorOptions {
     page: number;
     totalPages: number | null;
@@ -89,6 +89,6 @@ export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Argum
         totalPagesExtractor?: (data: TotalPagesExtractorOptions<QueryResponse>) => number;
     };
 }
-declare type OmitUndefined<T> = T extends undefined ? never : T;
-export declare type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryCreatorArgs<QueryCreator>>, QueryStateData<QueryCreatorReturnType<QueryCreator>['state']>, InfinityResponse>;
+type OmitUndefined<T> = T extends undefined ? never : T;
+export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryCreatorArgs<QueryCreator>>, QueryStateData<QueryCreatorReturnType<QueryCreator>['state']>, InfinityResponse>;
 export {};

package/lib/query/query.d.ts

@@ -1,7 +1,7 @@
 import { DefaultResponseTransformer, QueryClient, ResponseTransformerType } from '../query-client';
 import { Method as MethodType } from '../request';
-import { BaseArguments, GqlQueryConfig, PollConfig, QueryConfig, QueryState, RouteType, RunQueryOptions } from './query.types';
-export declare class Query<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
+import { BaseArguments, GqlQueryConfig, PollConfig, QueryState, RestQueryConfig, RouteType, RunQueryOptions, WithUseResultIn } from './query.types';
+export declare class Query<Response, Arguments extends (BaseArguments & WithUseResultIn<Response, ResponseTransformer>) | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
     private _client;
     private _queryConfig;
     private _route;
@@ -9,16 +9,18 @@ export declare class Query<Response, Arguments extends BaseArguments | undefined
     private _currentId;
     private _abortController;
     private _pollingSubscription;
+    private _onAbort$;
     private readonly _state$;
     private get _nextId();
     get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
     get state(): QueryState<ReturnType<ResponseTransformer>, Response>;
     get isExpired(): boolean;
-    constructor(_client: QueryClient, _queryConfig: QueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _route: Route, _args: Arguments | undefined);
+    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _route: Route, _args: Arguments | undefined);
     clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;
     execute<ComputedResponse extends ReturnType<ResponseTransformer>>(options?: RunQueryOptions): this;
     abort(): this;
     poll(config: PollConfig): this;
     stopPolling(): this;
+    private _updateUseResultInDependencies;
     private _handleExecuteError;
 }

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

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { ResponseTransformerType } from '../query-client';
 import { Method, PathParams, QueryParams, RequestError } from '../request';
 import { Query } from './query';
-export interface QueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
+export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
     /**
      * The http method to use for the query.
      */
@@ -51,9 +51,9 @@ export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined,
         args?: Arguments;
     };
 }
-export declare type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<QueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
-export declare type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
-export declare type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams;
+export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<RestQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
+export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
+export type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams;
 export interface WithHeaders {
     headers?: Record<string, string>;
 }
@@ -69,14 +69,17 @@ export interface WithQueryParams {
 export interface WithPathParams {
     pathParams?: PathParams;
 }
-export declare type EmptyObject = {};
+export type WithUseResultIn<Response, ResponseTransformer extends ResponseTransformerType<Response>> = {
+    useResultIn?: Query<Response, any, any, any, ResponseTransformer>[];
+};
+export type EmptyObject = {};
 export interface RunQueryOptions {
     skipCache?: boolean;
 }
-export declare type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
+export type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
     pathParams: infer PathParams;
 } ? (p: PathParams) => RouteString : RouteString;
-export declare type RouteString = `/${string}`;
+export type RouteString = `/${string}`;
 export interface PollConfig {
     interval: number;
     takeUntil: Observable<unknown>;
@@ -117,12 +120,12 @@ export interface QueryStateMeta {
 export interface QueryStateSuccessMeta extends QueryStateMeta {
     readonly expiresAt: number | null;
 }
-export declare type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
-export declare type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
-export declare type QueryStateRawData<T extends QueryState = QueryState> = T extends Success<infer Response, infer RawResponse> ? RawResponse : never;
-export declare type AnyQuery = Query<any, any, any, any, any>;
-export declare type QueryType<T extends {
+export type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
+export type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
+export type QueryStateRawData<T extends QueryState = QueryState> = T extends Success<infer Response, infer RawResponse> ? RawResponse : never;
+export type AnyQuery = Query<any, any, any, any, any>;
+export type QueryType<T extends {
     prepare: (args: any) => AnyQuery;
 }> = T['prepare'] extends () => infer R ? R : T['prepare'] extends (args: any) => infer R ? R : never;
-export declare type QueryResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateData<Q['state']> | null : null;
-export declare type QueryRawResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateRawData<Q['state']> | null : null;
+export type QueryResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateData<Q['state']> | null : null;
+export type QueryRawResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateRawData<Q['state']> | null : null;

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

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { ResponseTransformerType } from '../query-client';
 import { RequestHeaders } from '../request';
 import { AnyQuery, BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryRawResponseType, QueryResponseType, QueryState, QueryStateData, QueryStateRawData, QueryStateType, RouteType, Success } from './query.types';
-declare type OmitNull<T> = T extends null ? never : T;
+type OmitNull<T> = T extends null ? never : T;
 export declare function filterSuccess(): <T extends QueryState<unknown, unknown> | null, Response_1 extends QueryStateData<OmitNull<T>>, RawResponse extends QueryStateRawData<OmitNull<T>>>(source: Observable<T>) => Observable<Success<Response_1, RawResponse>>;
 export declare function filterFailure(): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<Failure>;
 export declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<T>;

package/lib/query-client/query-client.d.ts

@@ -1,5 +1,5 @@
 import { AuthProvider } from '../auth';
-import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfig, QueryConfigWithoutMethod, RouteType } from '../query';
+import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfigWithoutMethod, RestQueryConfig, RouteType } from '../query';
 import { Method as MethodType } from '../request';
 import { DefaultResponseTransformer, QueryClientConfig, QueryCreator, ResponseTransformerType } from './query-client.types';
 export declare class QueryClient {
@@ -9,14 +9,14 @@ export declare class QueryClient {
     get config(): QueryClientConfig;
     get authProvider(): AuthProvider | null;
     constructor(_clientConfig: QueryClientConfig);
-    get: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GET", Response_1, Route, ResponseTransformer>;
-    post: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "POST", Response_1, Route, ResponseTransformer>;
-    put: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PUT", Response_1, Route, ResponseTransformer>;
-    patch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PATCH", Response_1, Route, ResponseTransformer>;
-    delete: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "DELETE", Response_1, Route, ResponseTransformer>;
-    gqlQuery: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_QUERY", Response_1, Route, ResponseTransformer>;
-    gqlMutate: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_MUTATE", Response_1, Route, ResponseTransformer>;
-    fetch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfig<Route, Response_1, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, Method, Response_1, Route, ResponseTransformer>;
+    get: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GET", Response_1, Route, ResponseTransformer>;
+    post: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "POST", Response_1, Route, ResponseTransformer>;
+    put: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PUT", Response_1, Route, ResponseTransformer>;
+    patch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PATCH", Response_1, Route, ResponseTransformer>;
+    delete: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "DELETE", Response_1, Route, ResponseTransformer>;
+    gqlQuery: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_QUERY", Response_1, Route, ResponseTransformer>;
+    gqlMutate: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_MUTATE", Response_1, Route, ResponseTransformer>;
+    fetch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: RestQueryConfig<Route, Response_1, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, Method, Response_1, Route, ResponseTransformer>;
     setAuthProvider: (authProvider: AuthProvider) => void;
     clearAuthProvider: () => void;
 }

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

@@ -1,6 +1,6 @@
 import { BehaviorSubject } from 'rxjs';
 import { Query } from '../query/query';
-import { BaseArguments, EmptyObject, RouteType, WithHeaders } from '../query/query.types';
+import { BaseArguments, EmptyObject, RouteType, WithHeaders, WithUseResultIn } from '../query/query.types';
 import { CacheAdapterFn, Method as MethodType } from '../request';
 export interface QueryClientConfig {
     /**
@@ -33,15 +33,15 @@ export interface QueryClientConfig {
         cacheAdapter?: CacheAdapterFn;
     };
 }
-export declare type QueryCreator<Arguments extends BaseArguments | undefined, Method extends MethodType, Response, Route extends RouteType<Arguments>, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> = (Arguments extends Record<string, unknown> ? {
-    prepare: (args: Arguments & WithHeaders) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+export type QueryCreator<Arguments extends BaseArguments | undefined, Method extends MethodType, Response, Route extends RouteType<Arguments>, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> = (Arguments extends BaseArguments ? {
+    prepare: (args: Arguments & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
 } : {
-    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
 }) & {
     behaviorSubject: <T extends Query<Response, Arguments, Route, Method, ResponseTransformer>>(initialValue?: T | null) => BehaviorSubject<T | null>;
 };
-export declare type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
-export declare type QueryCreatorArgs<T extends AnyQueryCreator> = Parameters<T['prepare']>[0];
-export declare type ResponseTransformerType<Response> = (response: Response) => unknown;
-export declare type DefaultResponseTransformer<Response> = (response: Response) => Response;
-export declare type QueryCreatorReturnType<T extends AnyQueryCreator> = ReturnType<T['prepare']>;
+export type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
+export type QueryCreatorArgs<T extends AnyQueryCreator> = Parameters<T['prepare']>[0];
+export type ResponseTransformerType<Response> = (response: Response) => unknown;
+export type DefaultResponseTransformer<Response> = (response: Response) => Response;
+export type QueryCreatorReturnType<T extends AnyQueryCreator> = ReturnType<T['prepare']>;

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

@@ -45,9 +45,9 @@ export interface QueryFieldOptions<T = unknown> {
      */
     valueToQueryParamTransformFn?: (val: T | null) => unknown;
 }
-export declare type QueryFormGroup<T extends Record<string, QueryField<any>>> = {
+export type QueryFormGroup<T extends Record<string, QueryField<any>>> = {
     [Property in keyof T]: T[Property]['control'];
 };
-export declare type QueryFormValue<T extends Record<string, QueryField<any>>> = {
+export type QueryFormValue<T extends Record<string, QueryField<any>>> = {
     [Property in keyof T]: T[Property]['control']['value'];
 };

package/lib/request/request.types.d.ts

@@ -1,4 +1,4 @@
-export declare type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
 export interface RequestError<Detail = unknown> {
     code: number;
     message: string;
@@ -7,12 +7,12 @@ export interface RequestError<Detail = unknown> {
     route: string;
     requestInit?: RequestInit;
 }
-export declare type ParamPrimitive = string | number | boolean | null | undefined;
-export declare type Params = Record<string | number | symbol, ParamPrimitive | ParamArray>;
-export declare type ParamArray = Array<ParamPrimitive>;
-export declare type UnfilteredParamPrimitive = string | number | boolean | null | undefined;
-export declare type QueryParams = Record<string | number | symbol, UnfilteredParamPrimitive | UnfilteredParamArray>;
-export declare type PathParams = Record<string, string | number>;
-export declare type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
-export declare type CacheAdapterFn = (headers: Headers) => number | null;
-export declare type RequestHeaders = Record<string, string>;
+export type ParamPrimitive = string | number | boolean | null | undefined;
+export type Params = Record<string | number | symbol, ParamPrimitive | ParamArray>;
+export type ParamArray = Array<ParamPrimitive>;
+export type UnfilteredParamPrimitive = string | number | boolean | null | undefined;
+export type QueryParams = Record<string | number | symbol, UnfilteredParamPrimitive | UnfilteredParamArray>;
+export type PathParams = Record<string, string | number>;
+export type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
+export type CacheAdapterFn = (headers: Headers) => number | null;
+export type RequestHeaders = Record<string, string>;

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@ethlete/query",
-  "version": "0.1.0-next.10",
+  "version": "0.1.0-next.11",
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
     "@angular/common": "^14.2.0 || ^15.0.0",
     "@angular/core": "^14.2.0 || ^15.0.0",
-    "rxjs": "7.5.7",
-    "@ethlete/core": "0.2.0-next.8",
-    "@angular/forms": "15.0.2",
-    "@angular/router": "15.0.2"
+    "rxjs": "7.8.0",
+    "@ethlete/core": "0.2.0-next.10",
+    "@angular/forms": "15.1.0",
+    "@angular/router": "15.1.0"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",