type ApiRequestOptions = {
    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
    readonly url: string;
    readonly path?: Record<string, any>;
    readonly cookies?: Record<string, any>;
    readonly headers?: Record<string, any>;
    readonly query?: Record<string, any>;
    readonly formData?: Record<string, any>;
    readonly body?: any;
    readonly mediaType?: string;
    readonly responseHeader?: string;
    readonly errors?: Record<number, string>;
};

type ApiResult = {
    readonly url: string;
    readonly ok: boolean;
    readonly status: number;
    readonly statusText: string;
    readonly body: any;
};

declare class ApiError extends Error {
    readonly url: string;
    readonly status: number;
    readonly statusText: string;
    readonly body: any;
    readonly request: ApiRequestOptions;
    readonly retryAfter?: number;
    readonly rateLimitReset?: number;
    readonly rateLimitRemaining?: number;
    readonly rateLimitLimit?: number;
    constructor(request: ApiRequestOptions, response: ApiResult, message: string, rateLimitInfo?: {
        retryAfter?: number;
        rateLimitReset?: number;
        rateLimitRemaining?: number;
        rateLimitLimit?: number;
    });
    isRateLimitError(): boolean;
}

type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
type Headers = Record<string, string>;
type OpenAPIConfig = {
    BASE: string;
    VERSION: string;
    WITH_CREDENTIALS: boolean;
    CREDENTIALS: 'include' | 'omit' | 'same-origin';
    TOKEN?: string | Resolver<string> | undefined;
    USERNAME?: string | Resolver<string> | undefined;
    PASSWORD?: string | Resolver<string> | undefined;
    HEADERS?: Headers | Resolver<Headers> | undefined;
    ENCODE_PATH?: ((path: string) => string) | undefined;
};

interface RateLimitConfig {
    enabled: boolean;
    maxRetries: number;
    initialRetryDelay: number;
    backoffMultiplier: number;
    headerNames: {
        retryAfter?: string;
        resetTime?: string;
        remaining?: string;
        limit?: string;
    };
    isRateLimitError?: (status: number, body: any) => boolean;
}

interface OnCancel {
    readonly isResolved: boolean;
    readonly isRejected: boolean;
    readonly isCancelled: boolean;
    (cancelHandler: () => void): void;
}
declare class CancelablePromise<T> implements Promise<T> {
    #private;
    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
    get [Symbol.toStringTag](): string;
    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
    finally(onFinally?: (() => void) | null): Promise<T>;
    cancel(): void;
    get isCancelled(): boolean;
}

interface RequestOptions {
    rateLimitConfig?: RateLimitConfig;
}
declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions, requestOptions?: RequestOptions) => CancelablePromise<T>;

type WebhookEventHandler<TEvent = any> = (event: TEvent) => void | Promise<void>;
interface BaseHandleWebhookResult {
    success: boolean;
    error?: string;
}
declare abstract class BaseWebhookHandler<TEventName extends string = string, TEvent = any> {
    protected handlers: Map<TEventName, WebhookEventHandler<TEvent>[]>;
    on(eventName: TEventName, handler: WebhookEventHandler<TEvent>): this;
    off(eventName: TEventName, handler: WebhookEventHandler<TEvent>): this;
    getRegisteredEvents(): TEventName[];
    hasHandlers(eventName: TEventName): boolean;
    clearHandlers(eventName?: TEventName): this;
    protected executeHandlers(eventName: TEventName, event: TEvent): Promise<void>;
}

declare function verifyHmacSignature(payload: string | Buffer, secret: string, signature: string, algorithm?: 'sha256' | 'sha1'): boolean;
declare function verifyHmacSignatureWithPrefix(payload: string | Buffer, secret: string, signature: string, prefix: string, algorithm?: 'sha256' | 'sha1'): boolean;
declare function verifyHmacSha256Signature(payload: string, secret: string, timestamp: string, signature: string, maxAgeSeconds?: number): boolean;
declare function verifySlackSignature(payload: string, secret: string, timestamp: string, signature: string, maxAgeSeconds?: number): boolean;

export { ApiError, type ApiRequestOptions, type ApiResult, type BaseHandleWebhookResult, BaseWebhookHandler, type OpenAPIConfig, type RateLimitConfig, type WebhookEventHandler, request, verifyHmacSha256Signature, verifyHmacSignature, verifyHmacSignatureWithPrefix, verifySlackSignature };