@algolia/client-common 5.0.0-alpha.52 → 5.0.0-alpha.54

package/dist/src/transporter/createTransporter.d.ts

@@ -1,3 +1,3 @@
-import type { TransporterOptions, Transporter } from '../types';
-export declare function createTransporter({ hosts, hostsCache, baseHeaders, baseQueryParameters, algoliaAgent, timeouts, requester, requestsCache, responsesCache, }: TransporterOptions): Transporter;
+import type { TransporterOptions, Transporter } from '../types';
+export declare function createTransporter({ hosts, hostsCache, baseHeaders, baseQueryParameters, algoliaAgent, timeouts, requester, requestsCache, responsesCache, }: TransporterOptions): Transporter;
 //# sourceMappingURL=createTransporter.d.ts.map

package/dist/src/transporter/errors.d.ts

@@ -1,38 +1,38 @@
-import type { Response, StackFrame } from '../types';
-export declare class AlgoliaError extends Error {
-    name: string;
-    constructor(message: string, name: string);
-}
-export declare class ErrorWithStackTrace extends AlgoliaError {
-    stackTrace: StackFrame[];
-    constructor(message: string, stackTrace: StackFrame[], name: string);
-}
-export declare class RetryError extends ErrorWithStackTrace {
-    constructor(stackTrace: StackFrame[]);
-}
-export declare class ApiError extends ErrorWithStackTrace {
-    status: number;
-    constructor(message: string, status: number, stackTrace: StackFrame[], name?: string);
-}
-export declare class DeserializationError extends AlgoliaError {
-    response: Response;
-    constructor(message: string, response: Response);
-}
-export type DetailedErrorWithMessage = {
-    message: string;
-    label: string;
-};
-export type DetailedErrorWithTypeID = {
-    id: string;
-    type: string;
-    name?: string;
-};
-export type DetailedError = {
-    code: string;
-    details?: DetailedErrorWithMessage[] | DetailedErrorWithTypeID[];
-};
-export declare class DetailedApiError extends ApiError {
-    error: DetailedError;
-    constructor(message: string, status: number, error: DetailedError, stackTrace: StackFrame[]);
-}
+import type { Response, StackFrame } from '../types';
+export declare class AlgoliaError extends Error {
+    name: string;
+    constructor(message: string, name: string);
+}
+export declare class ErrorWithStackTrace extends AlgoliaError {
+    stackTrace: StackFrame[];
+    constructor(message: string, stackTrace: StackFrame[], name: string);
+}
+export declare class RetryError extends ErrorWithStackTrace {
+    constructor(stackTrace: StackFrame[]);
+}
+export declare class ApiError extends ErrorWithStackTrace {
+    status: number;
+    constructor(message: string, status: number, stackTrace: StackFrame[], name?: string);
+}
+export declare class DeserializationError extends AlgoliaError {
+    response: Response;
+    constructor(message: string, response: Response);
+}
+export type DetailedErrorWithMessage = {
+    message: string;
+    label: string;
+};
+export type DetailedErrorWithTypeID = {
+    id: string;
+    type: string;
+    name?: string;
+};
+export type DetailedError = {
+    code: string;
+    details?: DetailedErrorWithMessage[] | DetailedErrorWithTypeID[];
+};
+export declare class DetailedApiError extends ApiError {
+    error: DetailedError;
+    constructor(message: string, status: number, error: DetailedError, stackTrace: StackFrame[]);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/src/transporter/helpers.d.ts

@@ -1,9 +1,9 @@
-import type { Headers, Host, QueryParameters, Request, RequestOptions, Response, StackFrame } from '../types';
-export declare function shuffle<TData>(array: TData[]): TData[];
-export declare function serializeUrl(host: Host, path: string, queryParameters: QueryParameters): string;
-export declare function serializeQueryParameters(parameters: QueryParameters): string;
-export declare function serializeData(request: Request, requestOptions: RequestOptions): string | undefined;
-export declare function serializeHeaders(baseHeaders: Headers, requestHeaders: Headers, requestOptionsHeaders?: Headers): Headers;
-export declare function deserializeSuccess<TObject>(response: Response): TObject;
-export declare function deserializeFailure({ content, status }: Response, stackFrame: StackFrame[]): Error;
+import type { Headers, Host, QueryParameters, Request, RequestOptions, Response, StackFrame } from '../types';
+export declare function shuffle<TData>(array: TData[]): TData[];
+export declare function serializeUrl(host: Host, path: string, queryParameters: QueryParameters): string;
+export declare function serializeQueryParameters(parameters: QueryParameters): string;
+export declare function serializeData(request: Request, requestOptions: RequestOptions): string | undefined;
+export declare function serializeHeaders(baseHeaders: Headers, requestHeaders: Headers, requestOptionsHeaders?: Headers): Headers;
+export declare function deserializeSuccess<TObject>(response: Response): TObject;
+export declare function deserializeFailure({ content, status }: Response, stackFrame: StackFrame[]): Error;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/src/transporter/index.d.ts

@@ -1,7 +1,7 @@
-export * from './createTransporter';
-export * from './createStatefulHost';
-export * from './errors';
-export * from './helpers';
-export * from './responses';
-export * from './stackTrace';
+export * from './createTransporter';
+export * from './createStatefulHost';
+export * from './errors';
+export * from './helpers';
+export * from './responses';
+export * from './stackTrace';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/transporter/responses.d.ts

@@ -1,5 +1,5 @@
-import type { Response } from '../types';
-export declare function isNetworkError({ isTimedOut, status, }: Omit<Response, 'content'>): boolean;
-export declare function isRetryable({ isTimedOut, status, }: Omit<Response, 'content'>): boolean;
-export declare function isSuccess({ status }: Pick<Response, 'status'>): boolean;
+import type { Response } from '../types';
+export declare function isNetworkError({ isTimedOut, status, }: Omit<Response, 'content'>): boolean;
+export declare function isRetryable({ isTimedOut, status, }: Omit<Response, 'content'>): boolean;
+export declare function isSuccess({ status }: Pick<Response, 'status'>): boolean;
 //# sourceMappingURL=responses.d.ts.map

package/dist/src/transporter/stackTrace.d.ts

@@ -1,4 +1,4 @@
-import type { StackFrame } from '../types';
-export declare function stackTraceWithoutCredentials(stackTrace: StackFrame[]): StackFrame[];
-export declare function stackFrameWithoutCredentials(stackFrame: StackFrame): StackFrame;
+import type { StackFrame } from '../types';
+export declare function stackTraceWithoutCredentials(stackTrace: StackFrame[]): StackFrame[];
+export declare function stackFrameWithoutCredentials(stackFrame: StackFrame): StackFrame;
 //# sourceMappingURL=stackTrace.d.ts.map

package/dist/src/types/cache.d.ts

@@ -1,47 +1,47 @@
-export type Cache = {
-    /**
-     * Gets the value of the given `key`.
-     */
-    get: <TValue>(key: Record<string, any> | string, defaultValue: () => Promise<TValue>, events?: CacheEvents<TValue>) => Promise<TValue>;
-    /**
-     * Sets the given value with the given `key`.
-     */
-    set: <TValue>(key: Record<string, any> | string, value: TValue) => Promise<TValue>;
-    /**
-     * Deletes the given `key`.
-     */
-    delete: (key: Record<string, any> | string) => Promise<void>;
-    /**
-     * Clears the cache.
-     */
-    clear: () => Promise<void>;
-};
-export type CacheEvents<TValue> = {
-    /**
-     * The callback when the given `key` is missing from the cache.
-     */
-    miss: (value: TValue) => Promise<any>;
-};
-export type MemoryCacheOptions = {
-    /**
-     * If keys and values should be serialized using `JSON.stringify`.
-     */
-    serializable?: boolean;
-};
-export type BrowserLocalStorageOptions = {
-    /**
-     * The cache key.
-     */
-    key: string;
-    /**
-     * The native local storage implementation.
-     */
-    localStorage?: Storage;
-};
-export type FallbackableCacheOptions = {
-    /**
-     * List of caches order by priority.
-     */
-    caches: Cache[];
-};
+export type Cache = {
+    /**
+     * Gets the value of the given `key`.
+     */
+    get: <TValue>(key: Record<string, any> | string, defaultValue: () => Promise<TValue>, events?: CacheEvents<TValue>) => Promise<TValue>;
+    /**
+     * Sets the given value with the given `key`.
+     */
+    set: <TValue>(key: Record<string, any> | string, value: TValue) => Promise<TValue>;
+    /**
+     * Deletes the given `key`.
+     */
+    delete: (key: Record<string, any> | string) => Promise<void>;
+    /**
+     * Clears the cache.
+     */
+    clear: () => Promise<void>;
+};
+export type CacheEvents<TValue> = {
+    /**
+     * The callback when the given `key` is missing from the cache.
+     */
+    miss: (value: TValue) => Promise<any>;
+};
+export type MemoryCacheOptions = {
+    /**
+     * If keys and values should be serialized using `JSON.stringify`.
+     */
+    serializable?: boolean;
+};
+export type BrowserLocalStorageOptions = {
+    /**
+     * The cache key.
+     */
+    key: string;
+    /**
+     * The native local storage implementation.
+     */
+    localStorage?: Storage;
+};
+export type FallbackableCacheOptions = {
+    /**
+     * List of caches order by priority.
+     */
+    caches: Cache[];
+};
 //# sourceMappingURL=cache.d.ts.map

package/dist/src/types/createClient.d.ts

@@ -1,12 +1,12 @@
-import type { AlgoliaAgentOptions, TransporterOptions } from './transporter';
-export type AuthMode = 'WithinHeaders' | 'WithinQueryParameters';
-type OverriddenTransporterOptions = 'baseHeaders' | 'baseQueryParameters' | 'hosts';
-export type CreateClientOptions = Omit<TransporterOptions, OverriddenTransporterOptions | 'algoliaAgent'> & Partial<Pick<TransporterOptions, OverriddenTransporterOptions>> & {
-    appId: string;
-    apiKey: string;
-    authMode?: AuthMode;
-    algoliaAgents: AlgoliaAgentOptions[];
-};
-export type ClientOptions = Partial<Omit<CreateClientOptions, 'apiKey' | 'appId'>>;
-export {};
+import type { AlgoliaAgentOptions, TransporterOptions } from './transporter';
+export type AuthMode = 'WithinHeaders' | 'WithinQueryParameters';
+type OverriddenTransporterOptions = 'baseHeaders' | 'baseQueryParameters' | 'hosts';
+export type CreateClientOptions = Omit<TransporterOptions, OverriddenTransporterOptions | 'algoliaAgent'> & Partial<Pick<TransporterOptions, OverriddenTransporterOptions>> & {
+    appId: string;
+    apiKey: string;
+    authMode?: AuthMode;
+    algoliaAgents: AlgoliaAgentOptions[];
+};
+export type ClientOptions = Partial<Omit<CreateClientOptions, 'apiKey' | 'appId'>>;
+export {};
 //# sourceMappingURL=createClient.d.ts.map

package/dist/src/types/createIterablePromise.d.ts

@@ -1,36 +1,36 @@
-export type IterableOptions<TResponse> = Partial<{
-    /**
-     * The function that runs right after the API call has been resolved, allows you to do anything with the response before `validate`.
-     */
-    aggregator: (response: TResponse) => void;
-    /**
-     * The `validate` condition to throw an error and its message.
-     */
-    error: {
-        /**
-         * The function to validate the error condition.
-         */
-        validate: (response: TResponse) => boolean;
-        /**
-         * The error message to throw.
-         */
-        message: (response: TResponse) => string;
-    };
-    /**
-     * The function to decide how long to wait between iterations.
-     */
-    timeout: () => number;
-}>;
-export type CreateIterablePromise<TResponse> = IterableOptions<TResponse> & {
-    /**
-     * The function to run, which returns a promise.
-     *
-     * The `previousResponse` parameter (`undefined` on the first call) allows you to build your request with incremental logic, to iterate on `page` or `cursor` for example.
-     */
-    func: (previousResponse?: TResponse) => Promise<TResponse>;
-    /**
-     * The validator function. It receive the resolved return of the API call.
-     */
-    validate: (response: TResponse) => boolean;
-};
+export type IterableOptions<TResponse> = Partial<{
+    /**
+     * The function that runs right after the API call has been resolved, allows you to do anything with the response before `validate`.
+     */
+    aggregator: (response: TResponse) => void;
+    /**
+     * The `validate` condition to throw an error and its message.
+     */
+    error: {
+        /**
+         * The function to validate the error condition.
+         */
+        validate: (response: TResponse) => boolean;
+        /**
+         * The error message to throw.
+         */
+        message: (response: TResponse) => string;
+    };
+    /**
+     * The function to decide how long to wait between iterations.
+     */
+    timeout: () => number;
+}>;
+export type CreateIterablePromise<TResponse> = IterableOptions<TResponse> & {
+    /**
+     * The function to run, which returns a promise.
+     *
+     * The `previousResponse` parameter (`undefined` on the first call) allows you to build your request with incremental logic, to iterate on `page` or `cursor` for example.
+     */
+    func: (previousResponse?: TResponse) => Promise<TResponse>;
+    /**
+     * The validator function. It receive the resolved return of the API call.
+     */
+    validate: (response: TResponse) => boolean;
+};
 //# sourceMappingURL=createIterablePromise.d.ts.map

package/dist/src/types/host.d.ts

@@ -1,33 +1,33 @@
-export type Host = {
-    /**
-     * The host URL.
-     */
-    url: string;
-    /**
-     * The accepted transporter.
-     */
-    accept: 'read' | 'readWrite' | 'write';
-    /**
-     * The protocol of the host URL.
-     */
-    protocol: 'http' | 'https';
-};
-export type StatefulHost = Host & {
-    /**
-     * The status of the host.
-     */
-    status: 'down' | 'timed out' | 'up';
-    /**
-     * The last update of the host status, used to compare with the expiration delay.
-     */
-    lastUpdate: number;
-    /**
-     * Returns whether the host is up or not.
-     */
-    isUp: () => boolean;
-    /**
-     * Returns whether the host is timed out or not.
-     */
-    isTimedOut: () => boolean;
-};
+export type Host = {
+    /**
+     * The host URL.
+     */
+    url: string;
+    /**
+     * The accepted transporter.
+     */
+    accept: 'read' | 'readWrite' | 'write';
+    /**
+     * The protocol of the host URL.
+     */
+    protocol: 'http' | 'https';
+};
+export type StatefulHost = Host & {
+    /**
+     * The status of the host.
+     */
+    status: 'down' | 'timed out' | 'up';
+    /**
+     * The last update of the host status, used to compare with the expiration delay.
+     */
+    lastUpdate: number;
+    /**
+     * Returns whether the host is up or not.
+     */
+    isUp: () => boolean;
+    /**
+     * Returns whether the host is timed out or not.
+     */
+    isTimedOut: () => boolean;
+};
 //# sourceMappingURL=host.d.ts.map

package/dist/src/types/index.d.ts

@@ -1,7 +1,7 @@
-export * from './cache';
-export * from './createClient';
-export * from './createIterablePromise';
-export * from './host';
-export * from './requester';
-export * from './transporter';
+export * from './cache';
+export * from './createClient';
+export * from './createIterablePromise';
+export * from './host';
+export * from './requester';
+export * from './transporter';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/types/requester.d.ts

@@ -1,66 +1,66 @@
-import type { Headers, QueryParameters } from './transporter';
-/**
- * The method of the request.
- */
-export type Method = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
-export type Request = {
-    method: Method;
-    /**
-     * The path of the REST API to send the request to.
-     */
-    path: string;
-    queryParameters: QueryParameters;
-    data?: Array<Record<string, any>> | Record<string, any>;
-    headers: Headers;
-    /**
-     * If the given request should persist on the cache. Keep in mind,
-     * that some methods may have this option enabled by default.
-     */
-    cacheable?: boolean;
-    /**
-     * Some POST methods in the Algolia REST API uses the `read` transporter.
-     * This information is defined at the spec level.
-     */
-    useReadTransporter?: boolean;
-};
-export type EndRequest = Pick<Request, 'headers' | 'method'> & {
-    /**
-     * The full URL of the REST API.
-     */
-    url: string;
-    /**
-     * The connection timeout, in milliseconds.
-     */
-    connectTimeout: number;
-    /**
-     * The response timeout, in milliseconds.
-     */
-    responseTimeout: number;
-    data?: string;
-};
-export type Response = {
-    /**
-     * The body of the response.
-     */
-    content: string;
-    /**
-     * Whether the API call is timed out or not.
-     */
-    isTimedOut: boolean;
-    /**
-     * The HTTP status code of the response.
-     */
-    status: number;
-};
-export type Requester = {
-    /**
-     * Sends the given `request` to the server.
-     */
-    send: (request: EndRequest) => Promise<Response>;
-};
-export type EchoResponse = Omit<EndRequest, 'data'> & Pick<Request, 'data' | 'path'> & {
-    host: string;
-    algoliaAgent: string;
-    searchParams?: Record<string, string>;
-};
+import type { Headers, QueryParameters } from './transporter';
+/**
+ * The method of the request.
+ */
+export type Method = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+export type Request = {
+    method: Method;
+    /**
+     * The path of the REST API to send the request to.
+     */
+    path: string;
+    queryParameters: QueryParameters;
+    data?: Array<Record<string, any>> | Record<string, any>;
+    headers: Headers;
+    /**
+     * If the given request should persist on the cache. Keep in mind,
+     * that some methods may have this option enabled by default.
+     */
+    cacheable?: boolean;
+    /**
+     * Some POST methods in the Algolia REST API uses the `read` transporter.
+     * This information is defined at the spec level.
+     */
+    useReadTransporter?: boolean;
+};
+export type EndRequest = Pick<Request, 'headers' | 'method'> & {
+    /**
+     * The full URL of the REST API.
+     */
+    url: string;
+    /**
+     * The connection timeout, in milliseconds.
+     */
+    connectTimeout: number;
+    /**
+     * The response timeout, in milliseconds.
+     */
+    responseTimeout: number;
+    data?: string;
+};
+export type Response = {
+    /**
+     * The body of the response.
+     */
+    content: string;
+    /**
+     * Whether the API call is timed out or not.
+     */
+    isTimedOut: boolean;
+    /**
+     * The HTTP status code of the response.
+     */
+    status: number;
+};
+export type Requester = {
+    /**
+     * Sends the given `request` to the server.
+     */
+    send: (request: EndRequest) => Promise<Response>;
+};
+export type EchoResponse = Omit<EndRequest, 'data'> & Pick<Request, 'data' | 'path'> & {
+    host: string;
+    algoliaAgent: string;
+    searchParams?: Record<string, string>;
+};
 //# sourceMappingURL=requester.d.ts.map