@azure-net/kit 3.1.0 → 3.9.1

package/README.md

@@ -10,8 +10,8 @@
 
 ## 🚀 What's included?
 
-- **Built-in store** — flexible and SSR-friendly state management powered by [edges-svelte](https://github.com/Pixel1917/edge-s).
-- **Localization and translation** — ready-to-use i18n solution ([edges-svelte-translations](https://github.com/Pixel1917/edges-svelte-translations)) for multilingual applications.
+- **Built-in store** — flexible and SSR-friendly state management powered by [@azure-net/edges](https://github.com/Pixel1917/edge-s).
+- **Localization and translation** — ready-to-use i18n solution ([@azure-net/edges-translations](https://github.com/Pixel1917/edges-svelte-translations)) for multilingual applications.
 - **Extensive utilities** — for working with text, objects, dates, and common tasks.
 - **Data validation** — handy rules and validators.
 - **Reusable base abstractions** — `Repositories`, `Services`, `Providers`, and `Datasources` for quick setup and reuse.

package/dist/core/delivery/injectableDependencies/AsyncHelpers.d.ts

@@ -9,7 +9,10 @@ export declare const createAsyncHelpers: <BaseError = unknown, Custom = unknown>
     parseError?: ReturnType<typeof createErrorParser<BaseError, Custom>>;
 }) => {
     createAsyncAction: <Res = unknown, Req = unknown>(action: ActionOrThunk<Res>, args?: {
-        beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;
+        beforeSend?: (actions: {
+            next: () => void;
+            abort: () => void;
+        }) => void | Promise<void>;
         onSuccess?: (result: AsyncActionResponse<Res, undefined, Custom>) => Promise<unknown> | unknown;
         onError?: (result: AsyncActionResponse<never, Req, Custom>) => Promise<unknown> | unknown;
         reject?: boolean;
@@ -21,7 +24,10 @@ export declare const createAsyncHelpers: <BaseError = unknown, Custom = unknown>
         maxRetries?: number;
     }) => Promise<AsyncActionResponse<Res, Req, Custom>>;
     createAsyncResource: <Res, Req_1 = unknown>(action: ActionOrThunk<Res>, args?: {
-        beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;
+        beforeSend?: (actions: {
+            next: () => void;
+            abort: () => void;
+        }) => void | Promise<void>;
         onSuccess?: (result: Res) => Promise<unknown> | unknown;
         onError?: (error: AppError<Req_1, Custom>) => Promise<unknown> | unknown;
         reject?: boolean;

package/dist/core/delivery/injectableDependencies/AsyncHelpers.js

@@ -20,11 +20,22 @@ export const createAsyncHelpers = (opts) => {
         }
         if (args?.beforeSend) {
             const beforeSendResult = await new Promise((resolve) => {
-                const next = () => resolve('next');
-                const abort = () => resolve('abort');
-                Promise.resolve(args.beforeSend(next, abort)).catch((err) => {
+                let settled = false;
+                const settle = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    resolve(value);
+                };
+                const next = () => settle('next');
+                const abort = () => settle('abort');
+                Promise.resolve(args.beforeSend({ next, abort }))
+                    .then(() => {
+                    settle('next');
+                })
+                    .catch((err) => {
                     console.error('Error in beforeSend:', err);
-                    resolve('abort');
+                    settle('abort');
                 });
             });
             if (beforeSendResult === 'abort') {
@@ -69,7 +80,7 @@ export const createAsyncHelpers = (opts) => {
                 return retryResult;
             }
             const { bus } = AppEvents();
-            bus.publish('OnAsyncHelperError', error);
+            bus.publish('OnAsyncHelperError', () => error);
             const result = { error, response: args?.fallbackResponse, success: false };
             await args?.onError?.(result);
             if (args?.reject)
@@ -84,11 +95,22 @@ export const createAsyncHelpers = (opts) => {
         }
         if (args?.beforeSend) {
             const beforeSendResult = await new Promise((resolve) => {
-                const next = () => resolve('next');
-                const abort = () => resolve('abort');
-                Promise.resolve(args.beforeSend(next, abort)).catch((err) => {
+                let settled = false;
+                const settle = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    resolve(value);
+                };
+                const next = () => settle('next');
+                const abort = () => settle('abort');
+                Promise.resolve(args.beforeSend({ next, abort }))
+                    .then(() => {
+                    settle('next');
+                })
+                    .catch((err) => {
                     console.error('Error in beforeSend:', err);
-                    resolve('abort');
+                    settle('abort');
                 });
             });
             if (beforeSendResult === 'abort') {
@@ -128,7 +150,7 @@ export const createAsyncHelpers = (opts) => {
                 return retryResult;
             }
             const { bus } = AppEvents();
-            bus.publish('OnAsyncHelperError', error);
+            bus.publish('OnAsyncHelperError', () => error);
             await args?.onError?.(error);
             if (args?.reject)
                 throw error;

package/dist/core/delivery/schema/Schema.js

@@ -1,4 +1,4 @@
-import { FormDataUtil } from 'azure-net-tools';
+import { FormDataUtil } from '@azure-net/tools';
 export class SchemaFail {
     _errors;
     constructor(_errors) {

package/dist/core/delivery/serverAction/CreateServerAction.js

@@ -1,6 +1,6 @@
 import { RequestContext } from '../../../edges/context/index.js';
 import { error, fail, redirect } from '@sveltejs/kit';
-import { EnvironmentUtil } from 'azure-net-tools';
+import { EnvironmentUtil } from '@azure-net/tools';
 export const createServerAction = (factory, inject) => {
     return () => {
         if (EnvironmentUtil.isBrowser) {

package/dist/core/infra/datasource/BaseDatasource.d.ts

@@ -1,16 +1,16 @@
-import { HttpService, HttpServiceResponse } from '../httpService/HttpService.js';
-import { QueryBuilder } from '../query/index.js';
+import { type IHttpServiceInstance, type IHttpServiceResponse } from '../httpService/HttpServiceInstance.js';
+import { type IQueryBuilderInstance } from '../query/index.js';
 export type CreateRequestCallbackType<T> = (params: {
-    http: HttpService;
-    query: QueryBuilder;
-}) => Promise<HttpServiceResponse<T>>;
-export declare class BaseHttpDatasource<TQueryBuilder extends QueryBuilder = QueryBuilder> {
-    protected readonly httpClient: HttpService;
-    protected readonly query: QueryBuilder;
+    http: IHttpServiceInstance;
+    query: IQueryBuilderInstance;
+}) => Promise<IHttpServiceResponse<T>>;
+export declare class BaseHttpDatasource {
+    protected readonly httpClient: IHttpServiceInstance;
+    protected readonly query: IQueryBuilderInstance;
     constructor(params: {
-        http?: HttpService;
-        query?: TQueryBuilder;
+        http?: IHttpServiceInstance;
+        query?: IQueryBuilderInstance;
     });
     private _createRawRequest;
-    readonly createRawRequest: <T>(callback: CreateRequestCallbackType<T>) => Promise<HttpServiceResponse<T>>;
+    readonly createRawRequest: <T>(callback: CreateRequestCallbackType<T>) => Promise<IHttpServiceResponse<T>>;
 }

package/dist/core/infra/datasource/BaseDatasource.js

@@ -1,11 +1,11 @@
-import { HttpService, HttpServiceError, HttpServiceResponse } from '../httpService/HttpService.js';
-import { QueryBuilder } from '../query/index.js';
+import { createHttpServiceInstance } from '../httpService/HttpServiceInstance.js';
+import { createQueryInstance } from '../query/index.js';
 export class BaseHttpDatasource {
     httpClient;
     query;
     constructor(params) {
-        this.httpClient = params.http ?? new HttpService({ baseUrl: '' });
-        this.query = params.query ?? new QueryBuilder();
+        this.httpClient = params.http ?? createHttpServiceInstance();
+        this.query = params.query ?? createQueryInstance();
     }
     async _createRawRequest(callback) {
         return await callback({ http: this.httpClient, query: this.query }).catch((err) => {

package/dist/core/infra/httpService/HttpServiceInstance.d.ts

@@ -0,0 +1,82 @@
+export type SearchParamsInit = string | string[][] | Record<string, string> | URLSearchParams | undefined;
+export type SearchParamsOption = SearchParamsInit | Record<string, string | number | boolean | undefined> | Array<Array<string | number | boolean>>;
+export declare enum HttpInstanceFetchMethods {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+export interface IHttpServiceResponse<T = unknown> {
+    headers: Record<string, string>;
+    status: number;
+    success: boolean;
+    data: T;
+    message: string;
+    raw?: Response;
+}
+export interface IHttpServiceError<T = unknown> extends IHttpServiceResponse<T> {
+    original?: Error;
+}
+export declare class HttpServiceResponse<T> implements IHttpServiceResponse<T> {
+    headers: Record<string, string>;
+    status: number;
+    success: boolean;
+    data: T;
+    message: string;
+    raw?: Response;
+    constructor({ headers, status, success, data, message, raw }: IHttpServiceResponse<T>);
+}
+export declare class HttpServiceError<T> implements IHttpServiceError<T> {
+    headers: Record<string, string>;
+    status: number;
+    success: boolean;
+    data: T;
+    message: string;
+    original?: Error;
+    raw?: Response;
+    constructor({ headers, status, success, data, message, original, raw }: IHttpServiceError<T>);
+}
+export interface HttpInstanceNormalizedRequest {
+    url: string | URL;
+    method: HttpInstanceFetchMethods;
+    headers: Headers;
+    body: BodyInit | null | undefined;
+    responseFormat: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
+    includeRaw: boolean;
+    timeout: number | false;
+    retry: number;
+    stringifyJson: (data: unknown) => string | undefined;
+    fetch: typeof fetch;
+    requestInit: Omit<RequestInit, 'method' | 'headers' | 'body'>;
+}
+export type HttpInstanceOnRequest = (request: HttpInstanceNormalizedRequest) => void | Promise<void>;
+export type HttpInstanceOnError = (error: HttpServiceError<unknown>, request: HttpInstanceNormalizedRequest) => HttpServiceError<unknown> | Promise<HttpServiceError<unknown>>;
+export type HttpInstanceDoFetch = <T = unknown>(request: HttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
+export interface IHttpInstanceOptions extends Omit<RequestInit, 'headers' | 'method'> {
+    headers?: NonNullable<RequestInit['headers']> | Record<string, string | undefined>;
+    json?: unknown;
+    stringifyJson?: (data: unknown) => string | undefined;
+    searchParams?: SearchParamsOption;
+    prefixUrl?: URL | string;
+    timeout?: number | false;
+    retry?: number;
+    includeRaw?: boolean;
+    responseFormat?: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
+    onRequest?: HttpInstanceOnRequest;
+    onError?: HttpInstanceOnError;
+    doFetch?: HttpInstanceDoFetch;
+}
+export type HttpInstanceRequestMethod = <T = unknown>(url: string | URL, options?: IHttpInstanceOptions) => Promise<IHttpServiceResponse<T>>;
+export interface IHttpServiceInstance {
+    get: HttpInstanceRequestMethod;
+    post: HttpInstanceRequestMethod;
+    put: HttpInstanceRequestMethod;
+    delete: HttpInstanceRequestMethod;
+    patch: HttpInstanceRequestMethod;
+    head: HttpInstanceRequestMethod;
+    options: HttpInstanceRequestMethod;
+}
+export declare const createHttpServiceInstance: (config?: IHttpInstanceOptions) => IHttpServiceInstance;

package/dist/core/infra/httpService/HttpServiceInstance.js

@@ -0,0 +1,342 @@
+import { BROWSER } from '@azure-net/tools/environment';
+import { RequestContext } from '@azure-net/edges/context';
+export var HttpInstanceFetchMethods;
+(function (HttpInstanceFetchMethods) {
+    HttpInstanceFetchMethods["GET"] = "GET";
+    HttpInstanceFetchMethods["POST"] = "POST";
+    HttpInstanceFetchMethods["PUT"] = "PUT";
+    HttpInstanceFetchMethods["PATCH"] = "PATCH";
+    HttpInstanceFetchMethods["DELETE"] = "DELETE";
+    HttpInstanceFetchMethods["HEAD"] = "HEAD";
+    HttpInstanceFetchMethods["OPTIONS"] = "OPTIONS";
+})(HttpInstanceFetchMethods || (HttpInstanceFetchMethods = {}));
+export class HttpServiceResponse {
+    headers;
+    status;
+    success;
+    data;
+    message;
+    raw;
+    constructor({ headers, status, success, data, message, raw }) {
+        this.headers = headers;
+        this.status = status;
+        this.success = success;
+        this.data = data;
+        this.message = message;
+        this.raw = raw;
+    }
+}
+export class HttpServiceError {
+    headers;
+    status;
+    success;
+    data;
+    message;
+    original;
+    raw;
+    constructor({ headers, status, success, data, message, original, raw }) {
+        this.headers = headers;
+        this.status = status;
+        this.success = success;
+        this.data = data;
+        this.message = message;
+        this.original = original;
+        this.raw = raw;
+    }
+}
+const stringifyJsonFunc = (data) => {
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isAbsoluteUrl = (value) => /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value);
+const normalizeHeaders = (headers) => {
+    if (!headers)
+        return new Headers();
+    if (headers instanceof Headers)
+        return new Headers(headers);
+    if (Array.isArray(headers))
+        return new Headers(headers);
+    return new Headers(Object.entries(headers).filter(([, value]) => value !== undefined));
+};
+const normalizeSearchParams = (value) => {
+    if (!value)
+        return new URLSearchParams();
+    if (value instanceof URLSearchParams)
+        return new URLSearchParams(value);
+    if (typeof value === 'string')
+        return new URLSearchParams(value);
+    if (Array.isArray(value)) {
+        const params = new URLSearchParams();
+        for (const [key, rawValue] of value) {
+            params.append(String(key), String(rawValue));
+        }
+        return params;
+    }
+    const params = new URLSearchParams();
+    for (const [key, rawValue] of Object.entries(value)) {
+        if (rawValue === undefined)
+            continue;
+        params.append(key, String(rawValue));
+    }
+    return params;
+};
+const mergeSearchParams = (base, extra) => {
+    if (!base && !extra)
+        return undefined;
+    const result = normalizeSearchParams(base);
+    const next = normalizeSearchParams(extra);
+    for (const [key, value] of next.entries()) {
+        result.append(key, value);
+    }
+    return result;
+};
+const mergeOptions = (base = {}, extra = {}) => {
+    const mergedHeaders = new Headers(normalizeHeaders(base.headers));
+    for (const [key, value] of normalizeHeaders(extra.headers).entries()) {
+        mergedHeaders.set(key, value);
+    }
+    const mergedSearchParams = mergeSearchParams(base.searchParams, extra.searchParams);
+    return {
+        ...base,
+        ...extra,
+        headers: mergedHeaders,
+        searchParams: mergedSearchParams,
+        stringifyJson: extra.stringifyJson ?? base.stringifyJson,
+        onRequest: extra.onRequest ?? base.onRequest,
+        onError: extra.onError ?? base.onError,
+        doFetch: extra.doFetch ?? base.doFetch
+    };
+};
+const mergeQueryToRelativeUrl = (url, searchParams) => {
+    const hashIndex = url.indexOf('#');
+    const hash = hashIndex >= 0 ? url.slice(hashIndex) : '';
+    const urlWithoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+    const queryIndex = urlWithoutHash.indexOf('?');
+    const path = queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
+    const query = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : '';
+    const merged = new URLSearchParams(query);
+    for (const [key, value] of searchParams.entries()) {
+        merged.append(key, value);
+    }
+    const nextQuery = merged.toString();
+    return `${path}${nextQuery ? `?${nextQuery}` : ''}${hash}`;
+};
+const resolveUrl = (target, baseUrl, searchParams) => {
+    if (!baseUrl && !searchParams)
+        return target;
+    let rawUrl = String(target);
+    if (baseUrl) {
+        const base = String(baseUrl);
+        rawUrl = isAbsoluteUrl(rawUrl) ? rawUrl : new URL(rawUrl, base).toString();
+    }
+    if (!searchParams)
+        return rawUrl;
+    const normalizedSearchParams = normalizeSearchParams(searchParams);
+    if (!normalizedSearchParams.size)
+        return rawUrl;
+    if (isAbsoluteUrl(rawUrl)) {
+        const absoluteUrl = new URL(rawUrl);
+        for (const [key, value] of normalizedSearchParams.entries()) {
+            absoluteUrl.searchParams.append(key, value);
+        }
+        return absoluteUrl.toString();
+    }
+    return mergeQueryToRelativeUrl(rawUrl, normalizedSearchParams);
+};
+const parseBodyByFormat = async (response, format) => {
+    switch (format) {
+        case 'blob':
+            return (await response.blob());
+        case 'text':
+            return (await response.text());
+        case 'arrayBuffer':
+            return (await response.arrayBuffer());
+        case 'body':
+            return response.body;
+        case 'json':
+            return (await response.json());
+        default:
+            return (await response.json());
+    }
+};
+const withTimeout = (signal, timeout) => {
+    if (!timeout || timeout <= 0) {
+        return { signal, clear: () => undefined };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('Request timeout exceeded')), timeout);
+    const abortBySource = () => controller.abort(signal?.reason);
+    if (signal) {
+        if (signal.aborted) {
+            abortBySource();
+        }
+        else {
+            signal.addEventListener('abort', abortBySource, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        clear: () => {
+            clearTimeout(timer);
+            if (signal)
+                signal.removeEventListener('abort', abortBySource);
+        }
+    };
+};
+const shouldRetryError = (error) => {
+    if (error instanceof HttpServiceError) {
+        return [408, 425, 429, 500, 502, 503, 504].includes(error.status);
+    }
+    return !(error instanceof Error && error.name === 'AbortError');
+};
+const normalizeUnknownError = (error) => {
+    if (error instanceof Error)
+        return error;
+    return new Error(String(error));
+};
+const defaultDoFetch = async (request) => {
+    const maxAttempts = Math.max(1, Math.floor(request.retry) + 1);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const timeoutState = withTimeout(request.requestInit.signal ?? null, request.timeout);
+        try {
+            const response = await request.fetch(request.url, {
+                ...request.requestInit,
+                method: request.method,
+                headers: request.headers,
+                body: request.body,
+                signal: timeoutState.signal ?? undefined
+            });
+            const rawResponse = request.includeRaw ? response.clone() : undefined;
+            const data = await parseBodyByFormat(response, request.responseFormat);
+            if (!response.ok) {
+                const httpError = new HttpServiceError({
+                    headers: Object.fromEntries(response.headers.entries()),
+                    status: response.status,
+                    success: false,
+                    data,
+                    message: `Request failed with status code ${response.status}`,
+                    raw: rawResponse
+                });
+                lastError = httpError;
+                if (attempt >= maxAttempts || !shouldRetryError(httpError)) {
+                    throw httpError;
+                }
+                continue;
+            }
+            return new HttpServiceResponse({
+                headers: Object.fromEntries(response.headers.entries()),
+                status: response.status,
+                success: true,
+                data,
+                message: 'Request completed',
+                raw: rawResponse
+            });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= maxAttempts || !shouldRetryError(error)) {
+                throw error;
+            }
+        }
+        finally {
+            timeoutState.clear();
+        }
+    }
+    throw lastError;
+};
+const makeMethod = (method, defaults) => {
+    return async (url, options = {}) => {
+        const merged = mergeOptions(defaults, options);
+        const stringifyJson = merged.stringifyJson ?? stringifyJsonFunc;
+        const fetcher = !BROWSER ? (RequestContext.current()?.event?.fetch ?? fetch) : fetch;
+        const headers = normalizeHeaders(merged.headers);
+        let body = merged.body;
+        if (merged.json !== undefined && body === undefined) {
+            body = stringifyJson(merged.json);
+            if (!headers.has('content-type')) {
+                headers.set('content-type', 'application/json');
+            }
+        }
+        const responseFormat = merged.responseFormat ?? 'json';
+        if (responseFormat === 'json' && !headers.has('accept')) {
+            headers.set('accept', 'application/json');
+        }
+        const normalizedRequest = {
+            url: resolveUrl(url, merged.prefixUrl, merged.searchParams),
+            method,
+            headers,
+            body,
+            responseFormat,
+            includeRaw: merged.includeRaw ?? false,
+            timeout: merged.timeout ?? 20000,
+            retry: merged.retry ?? 0,
+            stringifyJson,
+            fetch: fetcher,
+            requestInit: {
+                cache: merged.cache,
+                credentials: merged.credentials,
+                integrity: merged.integrity,
+                keepalive: merged.keepalive,
+                mode: merged.mode,
+                priority: merged.priority,
+                redirect: merged.redirect,
+                referrer: merged.referrer,
+                referrerPolicy: merged.referrerPolicy,
+                signal: merged.signal,
+                window: merged.window
+            }
+        };
+        const onRequest = options.onRequest ?? defaults.onRequest;
+        if (onRequest) {
+            await onRequest(normalizedRequest);
+        }
+        const doFetch = merged.doFetch ?? defaults.doFetch ?? defaultDoFetch;
+        try {
+            return await doFetch(normalizedRequest);
+        }
+        catch (error) {
+            const normalizedError = error instanceof HttpServiceError
+                ? error
+                : new HttpServiceError({
+                    headers: {},
+                    status: 500,
+                    success: false,
+                    data: undefined,
+                    message: normalizeUnknownError(error).message,
+                    original: normalizeUnknownError(error)
+                });
+            const onError = options.onError ?? defaults.onError;
+            if (!onError)
+                throw normalizedError;
+            const handledError = await onError(normalizedError, normalizedRequest);
+            if (!(handledError instanceof HttpServiceError)) {
+                throw new HttpServiceError({
+                    headers: normalizedError.headers,
+                    status: normalizedError.status,
+                    success: false,
+                    data: normalizedError.data,
+                    message: 'onError hook must return HttpServiceError',
+                    original: new Error(normalizedError.message)
+                });
+            }
+            throw handledError;
+        }
+    };
+};
+export const createHttpServiceInstance = (config = {}) => {
+    const defaults = { ...config };
+    return {
+        get: makeMethod(HttpInstanceFetchMethods.GET, defaults),
+        post: makeMethod(HttpInstanceFetchMethods.POST, defaults),
+        put: makeMethod(HttpInstanceFetchMethods.PUT, defaults),
+        delete: makeMethod(HttpInstanceFetchMethods.DELETE, defaults),
+        patch: makeMethod(HttpInstanceFetchMethods.PATCH, defaults),
+        head: makeMethod(HttpInstanceFetchMethods.HEAD, defaults),
+        options: makeMethod(HttpInstanceFetchMethods.OPTIONS, defaults)
+    };
+};

package/dist/core/infra/httpService/index.d.ts

@@ -1,2 +1,2 @@
-export * from './HttpService.js';
 export * from './Statuses.js';
+export * from './HttpServiceInstance.js';

package/dist/core/infra/httpService/index.js

@@ -1,2 +1,2 @@
-export * from './HttpService.js';
 export * from './Statuses.js';
+export * from './HttpServiceInstance.js';

package/dist/core/infra/query/QueryBuilder.d.ts

@@ -1,25 +1,13 @@
 export type ArrayFormat = 'repeat' | 'brackets' | 'comma' | 'json';
 export type ObjectFormat = 'default' | 'nested-brackets';
-export interface IQueryBuilder {
-    build(query: Record<string, unknown>, opts?: {
-        arrayFormat?: ArrayFormat;
-        objectFormat?: ObjectFormat;
-    }): string;
-    transform(object: object): object;
+export interface IQueryBuilderSettings<TTransformInput extends object = object> {
+    delimiter?: boolean;
+    arrayFormat?: ArrayFormat;
+    objectFormat?: ObjectFormat;
+    transform?: (obj: TTransformInput) => object;
 }
-export declare class QueryBuilder implements IQueryBuilder {
-    private readonly defaultArrayFormat;
-    private readonly defaultObjectFormat;
-    constructor(options?: {
-        arrayFormat?: ArrayFormat;
-        objectFormat?: ObjectFormat;
-    });
-    transform(object: object): object;
-    build(query?: object, opts?: {
-        delimiter?: boolean;
-        arrayFormat?: ArrayFormat;
-        objectFormat?: ObjectFormat;
-    }): string;
-    private serialize;
-    private encodeArray;
+export interface IQueryBuilderInstance<TTransformInput extends object = object> {
+    toString: (query: object, settings?: IQueryBuilderSettings<TTransformInput>) => string;
+    toSearchParams: (query: object, settings?: Omit<IQueryBuilderSettings<TTransformInput>, 'delimiter'>) => URLSearchParams;
 }
+export declare const createQueryInstance: <TTransformInput extends object = object>(defaults?: IQueryBuilderSettings<TTransformInput>) => IQueryBuilderInstance<TTransformInput>;