recker 1.0.26 → 1.0.27

package/dist/browser/core/client.d.ts

@@ -0,0 +1,118 @@
+import { ClientOptions, Middleware, ReckerRequest, ReckerResponse, RequestOptions, CacheStorage, PageResult } from '../types/index.js';
+import { RequestPromise } from './request-promise.js';
+import { PaginationOptions } from '../plugins/pagination.js';
+import { RetryOptions } from '../plugins/retry.js';
+import { CacheOptions } from '../plugins/cache.js';
+import { DedupOptions } from '../plugins/dedup.js';
+import { ReckerWebSocket, type WebSocketOptions } from '../websocket/client.js';
+import { type WhoisOptions, type WhoisResult } from '../utils/whois.js';
+import { type ScrapePromise } from '../plugins/scrape.js';
+import { HlsPromise, type HlsOptions } from '../plugins/hls.js';
+interface ClientCacheConfig extends Omit<CacheOptions, 'storage'> {
+    storage?: CacheStorage;
+    driver?: 'memory' | 'file';
+    fileStoragePath?: string;
+}
+export interface ExtendedClientOptions extends ClientOptions {
+    retry?: RetryOptions;
+    cache?: ClientCacheConfig;
+    dedup?: DedupOptions;
+}
+export declare class Client {
+    private baseUrl;
+    private middlewares;
+    private hooks;
+    private transport;
+    private defaultHeaders;
+    private defaultParams;
+    private paginationConfig?;
+    private handler;
+    private logger?;
+    private debugEnabled;
+    private agentManager?;
+    private concurrencyConfig;
+    private requestPool?;
+    private maxResponseSize?;
+    private cookieJar?;
+    private cookieIgnoreInvalid;
+    private defaultTimeout?;
+    constructor(options?: ExtendedClientOptions);
+    private createLoggingMiddleware;
+    private createMaxSizeMiddleware;
+    private setupCookieJar;
+    private createCookieMiddleware;
+    private splitSetCookieHeader;
+    private composeMiddlewares;
+    private hooksMiddleware;
+    private httpErrorMiddleware;
+    use(middleware: Middleware): this;
+    beforeRequest(hook: (req: ReckerRequest) => ReckerRequest | void | Promise<ReckerRequest | void>): this;
+    afterResponse(hook: (req: ReckerRequest, res: ReckerResponse) => ReckerResponse | void | Promise<ReckerResponse | void>): this;
+    onError(hook: (error: Error, req: ReckerRequest) => ReckerResponse | void | Promise<ReckerResponse | void>): this;
+    private buildUrl;
+    request<T = unknown>(path: string, options?: RequestOptions): RequestPromise<T>;
+    get<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    batch<T = ReckerResponse>(requests: Array<{
+        path: string;
+        options?: RequestOptions;
+    }>, options?: {
+        concurrency?: number;
+        mapResponse?: (res: ReckerResponse) => Promise<T> | T;
+    }): Promise<{
+        results: (T | Error)[];
+        stats: {
+            total: number;
+            successful: number;
+            failed: number;
+            duration: number;
+        };
+    }>;
+    multi<T = ReckerResponse>(requests: Array<{
+        path: string;
+        options?: RequestOptions;
+    }>, options?: {
+        concurrency?: number;
+        mapResponse?: (res: ReckerResponse) => Promise<T> | T;
+    }): Promise<{
+        results: (Error | T)[];
+        stats: {
+            total: number;
+            successful: number;
+            failed: number;
+            duration: number;
+        };
+    }>;
+    private requestWithBody;
+    post<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    put<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    patch<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    delete<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    head<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    options<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    trace<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    connect<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    purge<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    propfind<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    proppatch<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    mkcol<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    copy<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    move<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    lock<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    unlock<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
+    link<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    unlink<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    scrape(path: string, options?: RequestOptions): ScrapePromise<ReckerResponse>;
+    paginate<T>(path: string, options?: RequestOptions & PaginationOptions<T>): AsyncGenerator<T>;
+    pages<T = any>(path: string, options?: RequestOptions & PaginationOptions): AsyncGenerator<PageResult<T>>;
+    page<T = any>(path: string, pageNumber: number, options?: RequestOptions & {
+        pageParam?: string;
+    }): RequestPromise<T>;
+    getAll<T>(path: string, options?: RequestOptions & PaginationOptions<T>): Promise<T[]>;
+    websocket(path: string, options?: WebSocketOptions): ReckerWebSocket;
+    ws(path: string, options?: WebSocketOptions): ReckerWebSocket;
+    whois(query: string, options?: WhoisOptions): Promise<WhoisResult>;
+    isDomainAvailable(domain: string, options?: WhoisOptions): Promise<boolean>;
+    hls(manifestUrl: string, options?: HlsOptions): HlsPromise;
+}
+export declare function createClient(options?: ExtendedClientOptions): Client;
+export {};