export declare enum KosFetchMethods {
    GET = "GET",
    PUT = "PUT",
    POST = "POST",
    DELETE = "DELETE"
}
type FetchMethodStrings = keyof typeof KosFetchMethods;
export interface Headers {
    append(name: string, value: string): void;
    delete(name: string): void;
    get(name: string): string | null;
    has(name: string): boolean;
    set(name: string, value: string): void;
    forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
}
interface Body {
    readonly body: ReadableStream<Uint8Array> | null;
    readonly bodyUsed: boolean;
    arrayBuffer(): Promise<ArrayBuffer>;
    blob(): Promise<Blob>;
    formData(): Promise<FormData>;
    json<T = any>(): Promise<T | null>;
    text(): Promise<string>;
}
export interface Response extends Body {
    readonly headers: Headers;
    readonly ok: boolean;
    readonly redirected: boolean;
    readonly status: number;
    readonly statusText: string;
    readonly type: ResponseType;
    readonly url: string;
    clone(): Response;
}
/**
 * Represents the configuration options for performing a Kos WebSocket fetch operation.
 */
export interface KosFetchOptions {
    /**
     * The HTTP method for the request (e.g., 'GET', 'POST', 'PUT', 'DELETE', etc.).
     */
    method: FetchMethodStrings;
    /**
     * The request body - can be string, ArrayBuffer, Blob, or FormData.
     */
    body?: string | ArrayBuffer | Blob | FormData | Uint8Array;
    /**
     * Indicates whether the request should be ordered.
     */
    ordered?: boolean;
    /**
     * The destination address for the WebSocket request.
     */
    destinationAddress?: string;
    /**
     * @internal
     */
    signal?: AbortSignal;
    /**
     * The tracker associated with the request.
     */
    tracker?: string;
    /**
     * @internal
     */
    studio?: boolean;
    /**
     * @internal
     */
    fos?: boolean;
    /**
     * @internal
     */
    bridge?: boolean;
    timeout?: number;
    headers?: Record<string, string>;
    /**
     * Enable streaming mode for large responses
     */
    stream?: boolean;
    /**
     * Response type hint for binary data handling
     */
    responseType?: "text" | "json" | "arraybuffer" | "blob";
}
export interface KosFetchResponse {
    headers: Headers;
    status: string | number | boolean;
    ok: boolean;
    json: <T = Record<string | number | symbol, string | number | symbol>>() => Promise<T>;
    body: ReadableStream<Uint8Array> | null;
}
export interface KosFetchReqeust {
    path: string;
    requestId: string;
    method: FetchMethodStrings;
    destinationAddress?: string;
    ordered?: boolean;
    tracker?: string;
    bridge?: boolean;
    headers?: Record<string, string | number | boolean>;
}
export interface KosMessageRequest extends Omit<KosFetchReqeust, "method" | "path" | "requestId"> {
    requestType: string;
    requestId?: string;
    headers?: Record<string, string>;
}
export interface KosBroadcastRequest {
    topic: string;
}
export interface KosMessageOptions extends KosBroadcastRequest {
    destinationAddress?: string;
    responseId?: string;
    type?: string;
}
export interface KosHttpMessageOptions {
    destinationAddress: string;
    sourceAddress: string;
    responseId: string;
    status: number;
    type: string;
    contentType?: string;
}
export interface KosFetchResponseParams {
    path: string;
    responseId?: string;
    destinationAddress: string;
    status: string | number | boolean;
}
export interface KosFetchPostReqeust extends KosFetchReqeust {
    body?: string;
}
export {};
//# sourceMappingURL=kos-fetch.d.ts.map