@ethlete/query 5.40.1 → 5.41.1

package/lib/experimental/auth/bearer-auth-provider-config.d.ts

@@ -1,123 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { QueryArgs, QueryClientRef, QueryCreator, RequestArgs, ResponseType } from '../http';
-import { BearerAuthProvider } from './bearer-auth-provider';
-export type BearerAuthProviderTokens = {
-    accessToken: string;
-    refreshToken: string;
-};
-export type BearerAuthProviderRouteConfig<TArgs extends QueryArgs> = {
-    queryCreator: QueryCreator<TArgs>;
-    /**
-     * A function that transforms the response into the format that the auth provider expects
-     *
-     * The expected format is an object with the `accessToken` and `refreshToken` properties.
-     *
-     * @default (response) => response
-     */
-    responseTransformer?: (response: ResponseType<TArgs>) => BearerAuthProviderTokens;
-};
-export type BearerAuthProviderCookieConfig<TTokenRefreshArgs extends QueryArgs> = {
-    /**
-     * The cookie name where the refresh token is stored
-     * @default 'etAuth'
-     */
-    name?: string;
-    /**
-     * The domain of the cookie. If not set, the current origin will be used.
-     *
-     * @example
-     * "https://example.com" -> "example.com"
-     * "https://sub.example.com" -> "example.com"
-     */
-    domain?: string;
-    /**
-     * The days until the cookie expires
-     * @default 30
-     */
-    expiresInDays?: number;
-    /**
-     * The path of the cookie
-     * @default '/'
-     */
-    path?: string;
-    /**
-     * Enable or disable the cookie
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * The same site property of the cookie
-     * @default 'lax'
-     */
-    sameSite?: 'strict' | 'none' | 'lax';
-    /**
-     * A function that turns the token gotten from the cookie into the body for the refresh token request
-     * @default (token) => ({ token })
-     */
-    refreshArgsTransformer?: (token: string) => RequestArgs<TTokenRefreshArgs>;
-    /**
-     * An array of routes where the auto login via cookie should not be triggered.
-     *
-     * This checks the current route against the array of routes using the `startsWith` method.
-     * Make sure to start each route with a `/`.
-     *
-     * @default []
-     * @example ['/login', '/register']
-     */
-    autoLoginExcludeRoutes?: string[];
-};
-export type CreateBearerAuthProviderConfigOptions<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = {
-    /**
-     * The name of the auth provider
-     */
-    name: string;
-    /**
-     * The query client reference
-     */
-    queryClientRef: QueryClientRef;
-    /**
-     * The login route configuration
-     */
-    login?: BearerAuthProviderRouteConfig<TLoginArgs>;
-    /**
-     * The token login route configuration
-     */
-    tokenLogin?: BearerAuthProviderRouteConfig<TTokenLoginArgs>;
-    /**
-     * The token refresh route configuration
-     */
-    tokenRefresh?: BearerAuthProviderRouteConfig<TTokenRefreshArgs>;
-    /**
-     * The select role route configuration
-     */
-    selectRole?: BearerAuthProviderRouteConfig<TSelectRoleArgs>;
-    /**
-     * The cookie configuration for the auth provider
-     */
-    cookie?: BearerAuthProviderCookieConfig<TTokenRefreshArgs>;
-    /**
-     * 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'
-     */
-    expiresInPropertyName?: string;
-    /**
-     * Determines if the token should be refreshed if **any** query returns a 401 response.
-     * @default true
-     */
-    refreshOnUnauthorizedResponse?: boolean;
-    /**
-     * A function that decrypts the bearer token
-     */
-    bearerDecryptFn?: (token: string) => TBearerData;
-};
-export type BearerAuthProviderConfig<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData> & {
-    token: BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
-};
-export type AnyBearerAuthProviderConfig = BearerAuthProviderConfig<any, any, any, any, any>;
-export type BearerAuthProviderRef<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = InjectionToken<BearerAuthProvider<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>>;
-export declare const createBearerAuthProviderConfig: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData>(options: CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>) => BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;

package/lib/experimental/auth/bearer-auth-provider.d.ts

@@ -1,69 +0,0 @@
-import { Signal } from '@angular/core';
-import { QueryArgs, QuerySnapshot, RequestArgs } from '../http';
-import { BearerAuthProviderConfig, BearerAuthProviderTokens } from './bearer-auth-provider-config';
-type QuerySnapshotWithType<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = ({
-    type: 'login';
-} & QuerySnapshot<TLoginArgs>) | ({
-    type: 'tokenLogin';
-} & QuerySnapshot<TTokenLoginArgs>) | ({
-    type: 'tokenRefresh';
-} & QuerySnapshot<TTokenRefreshArgs>) | ({
-    type: 'selectRole';
-} & QuerySnapshot<TSelectRoleArgs>);
-export type BearerAuthProvider<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = {
-    /**
-     * Logs in the user with the given args.
-     */
-    login: (args: RequestArgs<TLoginArgs>) => QuerySnapshot<TLoginArgs>;
-    /**
-     * Logs in the user with the given token.
-     */
-    loginWithToken: (args: RequestArgs<TTokenLoginArgs>) => QuerySnapshot<TTokenLoginArgs>;
-    /**
-     * Refreshes the token with the given refresh token.
-     */
-    refreshToken: (args: RequestArgs<TTokenRefreshArgs>) => QuerySnapshot<TTokenRefreshArgs>;
-    /**
-     * Selects the role for the user.
-     */
-    selectRole: (args: RequestArgs<TSelectRoleArgs>) => QuerySnapshot<TSelectRoleArgs>;
-    /**
-     * Logs out the user and removes the cookie.
-     */
-    logout: () => void;
-    /**
-     * Enables cookie usage for the auth provider.
-     */
-    enableCookie: () => void;
-    /**
-     * Disables cookie usage for the auth provider and removes the cookie.
-     */
-    disableCookie: () => void;
-    /**
-     * Checks if the cookie is present.
-     */
-    isCookiePresent: () => boolean;
-    /**
-     * Tries to login with the given cookie config.
-     * Returns `true` if a cookie was found, `false` otherwise.
-     */
-    tryLoginWithCookie: () => boolean;
-    /**
-     * The latest executed query that was not triggered internally.
-     */
-    latestExecutedQuery: Signal<QuerySnapshotWithType<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs> | null>;
-    /**
-     * A signal that contains the current access and refresh tokens.
-     */
-    tokens: Signal<BearerAuthProviderTokens | null>;
-    /**
-     * The bearer data that was decrypted from the access token.
-     */
-    bearerData: Signal<TBearerData | null>;
-};
-export declare const createBearerAuthProvider: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData>(options: BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>) => BearerAuthProvider<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
-export declare const provideBearerAuthProvider: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData>(config: BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>) => {
-    provide: import("./bearer-auth-provider-config").BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
-    useFactory: () => BearerAuthProvider<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
-};
-export {};

package/lib/experimental/auth/index.d.ts

@@ -1,2 +0,0 @@
-export * from './bearer-auth-provider';
-export * from './bearer-auth-provider-config';

package/lib/experimental/gql/gql-query-creator-templates.d.ts

@@ -1,12 +0,0 @@
-import { GQL } from '../../gql';
-import { QueryClientConfig } from '../http';
-import { GqlQueryArgs } from './gql-query';
-import { CreateGqlQueryCreatorOptions } from './gql-query-creator';
-/** A query creator that creates a GQL query where the payload is sent via GET (query params) */
-export declare const createGqlQueryViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
-/** A query creator that creates a GQL query where the payload is sent via POST (body) */
-export declare const createGqlQueryViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
-/** A query creator that creates a GQL mutation where the payload is sent via GET (query params) */
-export declare const createGqlMutationViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
-/** A query creator that creates a GQL mutation where the payload is sent via POST (body) */
-export declare const createGqlMutationViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;

package/lib/experimental/gql/gql-query-creator.d.ts

@@ -1,14 +0,0 @@
-import { CreateQueryCreatorOptions, QueryClientConfig, QueryCreator, RouteType } from '../http';
-import { GqlQueryArgs } from './gql-query';
-export type CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryCreatorOptions, 'route'> & {
-    route?: RouteType<TArgs>;
-};
-export type GqlQueryMethod = 'QUERY' | 'MUTATE';
-export type GqlQueryTransport = 'GET' | 'POST';
-export type InternalCreateGqlQueryCreatorOptions = {
-    method: GqlQueryMethod;
-    transport: GqlQueryTransport;
-    client: QueryClientConfig;
-    query: string;
-};
-export declare const createGqlQueryCreator: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryCreatorOptions<TArgs> | undefined, internals: InternalCreateGqlQueryCreatorOptions) => QueryCreator<TArgs>;

package/lib/experimental/gql/gql-query-execute.d.ts

@@ -1,11 +0,0 @@
-import { InternalQueryExecute, QueryArgs, QueryConfig, QueryDependencies, QueryState } from '../http';
-import { GqlQueryArgs } from './gql-query';
-import { CreateGqlQueryCreatorOptions, InternalCreateGqlQueryCreatorOptions } from './gql-query-creator';
-export type CreateGqlQueryExecuteOptions<TArgs extends QueryArgs> = {
-    deps: QueryDependencies;
-    state: QueryState<TArgs>;
-    creator?: CreateGqlQueryCreatorOptions<TArgs>;
-    creatorInternals: InternalCreateGqlQueryCreatorOptions;
-    queryConfig: QueryConfig;
-};
-export declare const createGqlExecuteFn: <TArgs extends GqlQueryArgs>(executeOptions: CreateGqlQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;

package/lib/experimental/gql/gql-query.d.ts

@@ -1,12 +0,0 @@
-import { CreateQueryOptions, QueryArgs } from '../http';
-import { CreateGqlQueryCreatorOptions, InternalCreateGqlQueryCreatorOptions } from './gql-query-creator';
-export type GqlQueryArgs = QueryArgs & {
-    variables?: Record<string, unknown>;
-};
-export type CreateGqlQueryOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creator' | 'creatorInternals'> & {
-    creator?: CreateGqlQueryCreatorOptions<TArgs>;
-    creatorInternals: InternalCreateGqlQueryCreatorOptions;
-};
-export type GqlVariablesType<T extends GqlQueryArgs | null> = T extends GqlQueryArgs ? T['variables'] : never;
-export declare const isCreateGqlQueryOptions: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<TArgs>) => options is CreateGqlQueryOptions<TArgs>;
-export declare const createGqlQuery: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryOptions<TArgs>) => import("../http").Query<TArgs>;

package/lib/experimental/gql/index.d.ts

@@ -1,4 +0,0 @@
-export * from './gql-query';
-export * from './gql-query-creator';
-export * from './gql-query-creator-templates';
-export * from './gql-query-execute';

package/lib/experimental/http/http-request.d.ts

@@ -1,119 +0,0 @@
-import { HttpClient, HttpContext, HttpEvent } from '@angular/common/http';
-import { ErrorHandler, Signal } from '@angular/core';
-import { QueryArgs, RequestArgs, ResponseType } from './query';
-import { CacheAdapterFn } from './query-client-config';
-import { QueryMethod } from './query-creator';
-import { QueryErrorResponse } from './query-error-response';
-import { QueryRepositoryDependencies } from './query-repository';
-import { ShouldRetryRequestFn } from './query-utils';
-export declare const SPEED_BUFFER_TIME_IN_MS = 2000;
-export type HttpRequestTransferCacheConfig = boolean | {
-    includeHeaders?: string[];
-};
-export type HttpRequestResponseType = 'json' | 'text' | 'blob' | 'arraybuffer';
-export type CreateHttpRequestDependencies = {
-    /** The http client instance to use for the request */
-    httpClient: HttpClient;
-    /** The error handler instance to use for the request */
-    ngErrorHandler: ErrorHandler;
-};
-export type CreateHttpRequestClientOptions = {
-    /**
-     * Whether to report the progress of the request or not. If the fetch backend is used, this will only work for downloads.
-     * @see https://angular.dev/guide/http/making-requests#receiving-raw-progress-events
-     * @default false
-     */
-    reportProgress?: boolean;
-    /**
-     * Whether to include credentials in the request or not
-     * @default false
-     */
-    withCredentials?: boolean;
-    /**
-     * This property accepts either a boolean to enable/disable transferring cache for eligible
-     * requests performed using `HttpClient`, or an object, which allows to configure cache
-     * parameters, such as which headers should be included (no headers are included by default).
-     *
-     * Setting this property will override the options passed to `provideClientHydration()` for this
-     * particular request
-     */
-    transferCache?: HttpRequestTransferCacheConfig;
-    /**
-     * The response type of the request
-     * @default 'json'
-     */
-    responseType?: HttpRequestResponseType;
-    /**
-     * The context of the request
-     * @default undefined
-     * @see https://angular.dev/guide/http/interceptors#request-and-response-metadata
-     */
-    context?: HttpContext;
-};
-export type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
-    /** The HTTP method of the request */
-    method: QueryMethod;
-    /**
-     * The full path of the request
-     * @example 'https://api.example.com/v1/users'
-     */
-    fullPath: string;
-    /** The data of the request */
-    args?: RequestArgs<TArgs> | null;
-    /** The dependencies of the request */
-    dependencies: QueryRepositoryDependencies;
-    /** The client options of the request */
-    clientOptions?: CreateHttpRequestClientOptions;
-    /**
-     * The cache adapter function to use for the request
-     * @default extractExpiresInSeconds()
-     */
-    cacheAdapter?: CacheAdapterFn;
-    /**
-     * The retry function to use for the request
-     * @default shouldRetryRequest()
-     */
-    retryFn?: ShouldRetryRequestFn;
-};
-export type HttpRequestLoadingState = {
-    /** The time when the request was executed in ms */
-    executeTime: number;
-    /** The progress of the request. Null if reportProgress is false or progress is not available / unsupported */
-    progress: HttpRequestLoadingProgressState | null;
-};
-export type HttpRequestLoadingProgressState = {
-    /** The total number of bytes to be transferred */
-    total: number;
-    /** The number of bytes transferred */
-    loaded: number;
-    /** The percentage of the transfer that is completed */
-    percentage: number;
-    /** The speed of the transfer in bytes per millisecond */
-    speed: number | null;
-    /** The estimated remaining time in milliseconds */
-    remainingTime: number | null;
-};
-export type HttpRequest<TArgs extends QueryArgs> = {
-    /** Executes the request */
-    execute: (options?: {
-        allowCache?: boolean;
-    }) => boolean;
-    /** Destroys the request (cancels it if in progress) */
-    destroy: () => boolean;
-    /** The loading state of the request */
-    loading: Signal<HttpRequestLoadingState | null>;
-    /** The error state of the request */
-    error: Signal<QueryErrorResponse | null>;
-    /** The response state of the request */
-    response: Signal<ResponseType<TArgs> | null>;
-    /** The current event of the request */
-    currentEvent: Signal<HttpEvent<ResponseType<TArgs>> | HttpErrorEvent | null>;
-    /** Whether the request is stale or not aka the cache header has expired */
-    isStale: Signal<boolean>;
-};
-/** A custom error event since the Angular http client does not provide a specific event for errors */
-export type HttpErrorEvent = {
-    type: 'error';
-    error: QueryErrorResponse;
-};
-export declare const createHttpRequest: <TArgs extends QueryArgs>(options: CreateHttpRequestOptions<TArgs>) => HttpRequest<TArgs>;

package/lib/experimental/http/index.d.ts

@@ -1,21 +0,0 @@
-export * from './http-request';
-export * from './paged-query-stack';
-export * from './query';
-export * from './query-client';
-export * from './query-client-config';
-export * from './query-creator';
-export * from './query-creator-templates';
-export * from './query-dependencies';
-export * from './query-error-response';
-export * from './query-errors';
-export * from './query-execute';
-export * from './query-execute-utils';
-export * from './query-features';
-export * from './query-repository';
-export * from './query-snapshot';
-export * from './query-stack';
-export * from './query-state';
-export * from './query-utils';
-export * from './secure-query';
-export * from './secure-query-creator';
-export * from './secure-query-execute';

package/lib/experimental/http/paged-query-stack.d.ts

@@ -1,172 +0,0 @@
-import { Signal } from '@angular/core';
-import { ContentfulGqlLikePaginated, DynLikePaginated, GgLikePaginated, NormalizedPagination, Paginated } from '@ethlete/types';
-import { AnyQuery, Query, QueryArgs, RequestArgs, ResponseType } from './query';
-import { AnyQueryCreator, QueryArgsOf, QueryCreator } from './query-creator';
-import { QueryErrorResponse } from './query-error-response';
-import { QueryFeature } from './query-features';
-export declare const ethletePaginationAdapter: <T>(response: Paginated<T>) => NormalizedPagination<T>;
-export declare const ggLikePaginationAdapter: <T>(response: GgLikePaginated<T>) => NormalizedPagination<T>;
-export declare const dynLikePaginationAdapter: <T>(response: DynLikePaginated<T>) => NormalizedPagination<T>;
-export declare const contentfulGqlLikePaginationAdapter: <T>(response: ContentfulGqlLikePaginated<T>) => NormalizedPagination<T>;
-export declare const fakePaginationAdapter: (totalHits?: number) => <T>(response: T) => NormalizedPagination<T>;
-export type CreatePagedQueryStackOptions<TArgs extends QueryArgs, TNormPagination extends NormalizedPagination<unknown>> = {
-    /**
-     * The normalizer function that will be used to normalize the response to a format that the paged query can understand.
-     *
-     * There are some built-in normalizers that can be used:
-     * - `ethletePaginationAdapter`
-     * - `ggLikePaginationAdapter`
-     * - `dynLikePaginationAdapter`
-     * - `contentfulGqlLikePaginationAdapter`
-     * - `fakePaginationAdapter` (for testing purposes)
-     *
-     * @param currentResponse The current response that was fetched.
-     * @param allResponses All responses that were fetched till now including the current response and pagination.
-     */
-    responseNormalizer: (currentResponse: ResponseType<TArgs>, allResponses: NonNullable<ResponseType<TArgs>>[]) => TNormPagination;
-    /**
-     * The query creator function that will be used to create the paged query.
-     */
-    queryCreator: QueryCreator<TArgs>;
-    /**
-     * The arguments to create the query.
-     * The current page will be passed as an argument.
-     * This function can be treated like a computed function. It reacts to signal changes.
-     * If a signal changes, the paged query will be reset to the initial page.
-     *
-     * @example (page) => ({ queryParams: { page, limit:20 } }),
-     *
-     * @param page The page to fetch next. **Do not modify this argument.**
-     * @param allResponses All responses that were fetched till now including pagination.
-     */
-    args: (page: number, allResponses: NonNullable<ResponseType<TArgs>>[]) => RequestArgs<TArgs> | null;
-    /**
-     * The features that should be used for all queries in the stack.
-     *
-     * @throws If the `withArgs` feature is used. This feature is internally used.
-     *
-     * @example
-     * // Due to limitations in TypeScript, you have to manually add the needed generic types if needed.
-     * features: [E.withSuccessHandling<GetPostQueryArgs>({ handler: (post) => console.log(post.title) })]
-     *
-     * @example
-     * // If typings are not needed, you can use the feature without generics.
-     * features: [E.withPolling({ interval: 5000 })]
-     */
-    features?: QueryFeature<any>[];
-    /**
-     * The page to start this paged query from.
-     * @default 1
-     */
-    initialPage?: number;
-    /**
-     * If true, no queries will be executed while the paged query is loading.
-     * This is useful if you need the current response to be used in the next query.
-     */
-    blockExecutionDuringLoading?: boolean;
-};
-export type PagedQueryStackResetOptions = {
-    /**
-     * The page to reset this paged query to.
-     * This will clear everything and start from this page.
-     * @default 1 // or the value passed in the `initialPage` option when creating the paged query.
-     */
-    initialPage?: number;
-};
-export type PagedQueryStackExecuteOptions<TNormPagination extends NormalizedPagination<unknown>> = {
-    /**
-     * If provided, only the queries that match the condition will be executed.
-     * This will also execute the previous and next query to the one that matched the condition.
-     * If not provided, all queries will be executed.
-     *
-     * @example
-     * myPagedQuery.execute({ where: (item) => item.id === 4 });
-     */
-    where?: (item: TNormPagination['items'][number], index: number, array: TNormPagination['items']) => boolean;
-    /**
-     * If true, the cache will be used (if not expired) and the request will not be made.
-     * @default false
-     */
-    allowCache?: boolean;
-};
-export type PagedQueryStackDirection = 'next' | 'previous';
-export type AnyPagedQueryStack = PagedQueryStack<AnyQuery, NormalizedPagination<unknown>>;
-export type PagedQueryStack<TQuery extends AnyQuery, TNormPagination extends NormalizedPagination<unknown>> = {
-    /**
-     * The pagination of the last executed query in the paged query.
-     */
-    maxPagination: Signal<TNormPagination | null>;
-    /**
-     * The pagination of the first executed query in the paged query.
-     */
-    minPagination: Signal<TNormPagination | null>;
-    /**
-     * Whether the last page of the paged query is loaded or not.
-     */
-    isLastPageLoaded: Signal<boolean>;
-    /**
-     * Whether the first page of the paged query is loaded or not.
-     */
-    isFirstPageLoaded: Signal<boolean>;
-    /**
-     * Fetches the previous page of the paged query.
-     *
-     * @throws If the paged query is already at the first page.
-     */
-    fetchPreviousPage: () => TQuery | null;
-    /**
-     * Fetches the next page of the paged query.
-     *
-     * @throws If the paged query is already at the last page.
-     */
-    fetchNextPage: () => TQuery | null;
-    /**
-     * Whether the previous page can be fetched or not.
-     *
-     * This will be false if the paged query is already at the first page or if the paged query is loading.
-     */
-    canFetchPreviousPage: Signal<boolean>;
-    /**
-     * Whether the next page can be fetched or not.
-     *
-     * This will be false if the paged query is already at the last page or if the paged query is loading.
-     */
-    canFetchNextPage: Signal<boolean>;
-    /**
-     * The items of the paged query.
-     */
-    items: Signal<TNormPagination['items']>;
-    /**
-     * Whether the paged query is loading or not.
-     */
-    loading: Signal<boolean>;
-    /**
-     * The error that occurred during the last execution of the paged query.
-     */
-    error: Signal<QueryErrorResponse | null>;
-    /**
-     * The last query executed in the paged query.
-     */
-    lastQuery: Signal<Query<QueryArgsOf<TQuery>> | null>;
-    /**
-     * Whether the paged query is on its first load or not.
-     */
-    isFirstLoad: Signal<boolean>;
-    /**
-     * The queries in the paged query stack.
-     */
-    queries: Signal<TQuery[]>;
-    /**
-     * Resets the paged query to the initial page.
-     */
-    reset: (resetOptions?: PagedQueryStackResetOptions) => void;
-    /**
-     * Executes the paged query.
-     */
-    execute: (options?: PagedQueryStackExecuteOptions<TNormPagination>) => void;
-    /**
-     * The current direction of the paged query.
-     */
-    direction: Signal<PagedQueryStackDirection>;
-};
-export declare const createPagedQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TNormPagination extends NormalizedPagination<unknown>>(options: CreatePagedQueryStackOptions<TArgs, TNormPagination>) => PagedQueryStack<Query<TArgs>, TNormPagination>;

package/lib/experimental/http/query-client-config.d.ts

@@ -1,45 +0,0 @@
-import { HttpHeaders } from '@angular/common/http';
-import { InjectionToken } from '@angular/core';
-import { BuildQueryStringConfig } from '../../request';
-import { QueryClient } from './query-client';
-import { ShouldRetryRequestFn } from './query-utils';
-export type CacheAdapterFn = (headers: HttpHeaders) => number | null;
-export type CreateQueryClientConfigOptions = {
-    /**
-     * The base URL of the client
-     * @example 'https://api.example.com/v1'
-     */
-    baseUrl: string;
-    /** Configuration for building query strings */
-    queryString?: BuildQueryStringConfig;
-    /** The name of the client */
-    name: string;
-    /**
-     * The cache adapter function to use for the client.
-     * It determines how long the response of a request can be cached.
-     *
-     * @default extractExpiresInSeconds()
-     */
-    cacheAdapter?: CacheAdapterFn;
-    /**
-     * The retry function to use for the client.
-     * It determines if a request should be retried after it failed.
-     *
-     * @default shouldRetryRequest()
-     */
-    retryFn?: ShouldRetryRequestFn;
-};
-export type QueryClientConfig = CreateQueryClientConfigOptions & {
-    /** A generated token for dependency injection */
-    token: QueryClientRef;
-};
-/**
- * A token for a query client.
- * This token can be used to inject a query client into a service.
- */
-export type QueryClientRef = InjectionToken<QueryClient>;
-/**
- * This function creates a query client config.
- * The config is used to create a query client using the `provideQueryClient(myConfig)` function.
- */
-export declare const createQueryClientConfig: (options: CreateQueryClientConfigOptions) => QueryClientConfig;

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

@@ -1,10 +0,0 @@
-import { QueryClientConfig } from './query-client-config';
-import { QueryRepository } from './query-repository';
-export type QueryClient = {
-    repository: QueryRepository;
-};
-export declare const createQueryClient: (config: QueryClientConfig) => QueryClient;
-export declare const provideQueryClient: (config: QueryClientConfig) => {
-    provide: import("./query-client-config").QueryClientRef;
-    useFactory: () => QueryClient;
-};

package/lib/experimental/http/query-creator-templates.d.ts

@@ -1,24 +0,0 @@
-import { AnyBearerAuthProviderConfig } from '../auth/bearer-auth-provider-config';
-import { QueryArgs } from './query';
-import { QueryClientConfig } from './query-client-config';
-import { CreateQueryCreatorOptions, RouteType } from './query-creator';
-/** A query creator that creates a GET query */
-export declare const createGetQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a secure GET query (requires authentication) */
-export declare const createSecureGetQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a POST query */
-export declare const createPostQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a secure POST query (requires authentication) */
-export declare const createSecurePostQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a PUT query */
-export declare const createPutQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a secure PUT query (requires authentication) */
-export declare const createSecurePutQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a DELETE query */
-export declare const createDeleteQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a secure DELETE query (requires authentication) */
-export declare const createSecureDeleteQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a PATCH query */
-export declare const createPatchQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
-/** A query creator that creates a secure PATCH query (requires authentication) */
-export declare const createSecurePatchQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;