import { type UUID } from 'node:crypto';
import { type Awaitable, Logger, SeyfertError } from '../common';
import { type WorkerSendApiRequest } from '../websocket/discord/worker';
import { Bucket } from './bucket';
import type { APIRoutes } from './Routes';
import { type ApiHandlerInternalOptions, type ApiHandlerOptions, type ApiRequestOptions, type HttpMethods, type RawFile, type RequestHeaders, type RestObserveOptions, type RestObserver, type RestObserverDisposer, type RestObserverEntry } from './shared';
export type { RestObserveOptions, RestObserver, RestObserverDisposer, RestObserverEntry, RestObserverFailPayload, RestObserverRatelimitPayload, RestObserverRequestPayload, RestObserverSuccessPayload, } from './shared';
export interface ApiHandler<TClient = unknown> {
    debugger?: Logger;
}
export type OnRatelimitCallback = (response: Response, request: ApiRequestOptions) => Awaitable<any>;
export type OnSuccessRequestCallback = (method: HttpMethods, url: `/${string}`, response: Response) => Awaitable<any>;
export type OnFailRequestCallback = (method: HttpMethods, url: `/${string}`, error: unknown, statusCode?: number) => Awaitable<any>;
export declare class ApiHandler<TClient = unknown> {
    options: ApiHandlerInternalOptions;
    globalBlock: boolean;
    ratelimits: Map<string, Bucket>;
    readyQueue: (() => void)[];
    cdn: import("..").CDNRoute;
    workerPromises?: Map<string, {
        resolve: (value: any) => any;
        reject: (error: any) => any;
    }>;
    onRatelimit?: OnRatelimitCallback;
    onSuccessRequest?: OnSuccessRequestCallback;
    onFailRequest?: OnFailRequestCallback;
    pluginRestObserverProvider?: () => readonly RestObserverEntry[];
    pluginRestObserverClient?: TClient;
    private restObservers;
    constructor(options: ApiHandlerOptions);
    observe(observer: RestObserver<TClient>, _opts?: RestObserveOptions): RestObserverDisposer;
    set debug(active: boolean);
    get proxy(): APIRoutes;
    globalUnblock(): void;
    randomUUID(): UUID;
    protected sendMessage(_body: WorkerSendApiRequest): void;
    protected postMessage<T = unknown>(body: WorkerSendApiRequest): Promise<T>;
    private notifyRequest;
    private notifySuccessRequest;
    private notifyFailRequest;
    private notifyRatelimit;
    private notifyRestObservers;
    private notifyRestObserverEntries;
    request<T = unknown>(method: HttpMethods, url: `/${string}`, request?: ApiRequestOptions): Promise<T>;
    parseError(method: HttpMethods, route: `/${string}`, response: Response, result: string | Record<string, any>, originTrace?: {
        stack?: string;
    }): SeyfertError;
    parseValidationError(data: Record<string, any>, path?: string, errors?: string[]): string[];
    handle50X(method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, attempts: number | (() => void), next?: () => void, resolve?: (value: unknown) => void, reject?: (err: unknown) => void): Promise<unknown>;
    handle429(route: string, method: HttpMethods, url: `/${string}`, request: ApiRequestOptions, response: Response, result: string, next: () => void, reject: (err: unknown) => void, now: number, notifyUrl: `/${string}`): Promise<unknown>;
    clearResetInterval(route: string): void;
    setResetBucket(route: string, resp: Response, now: number, headerNow: number): void;
    setRatelimitsBucket(route: string, resp: Response): void;
    parseRequest(options: {
        url: string;
        headers: RequestHeaders;
        request: ApiRequestOptions;
    }): {
        data: string | FormData | undefined;
        finalUrl: `/${string}`;
    };
    routefy(url: string, method: HttpMethods): `/${string}`;
}
export type RequestOptions = Pick<ApiRequestOptions, 'reason' | 'auth' | 'appendToFormData' | 'token'>;
export type RestArguments<B extends Record<string, any> | undefined, Q extends never | Record<string, any> = never, F extends RawFile[] = RawFile[]> = ({
    body: B;
    files?: F;
} | (Q extends never | undefined ? {} : {
    query?: Q;
})) & RequestOptions;
export type RestArgumentsNoBody<Q extends never | Record<string, any> = never> = {
    query?: Q;
    files?: RawFile[];
} & RequestOptions;
export type RestArgumentsRequiredQuery<Q extends Record<string, any>> = Omit<RestArgumentsNoBody<Q>, 'query'> & {
    query: Q;
};