import type { AppendOptions, AppendResult, DeleteOptions, DeleteResult, IngestOptions, IngestResult, QueryOptions, QueryResult, TruncateOptions, TruncateResult, TinybirdErrorResponse } from "../client/types.js";
/**
 * Public, decoupled Tinybird API wrapper configuration
 */
export interface TinybirdApiConfig {
    /** Tinybird API base URL (e.g. https://api.tinybird.co) */
    baseUrl: string;
    /** Tinybird token used for Authorization bearer header */
    token: string;
    /** Custom fetch implementation (optional) */
    fetch?: typeof fetch;
    /** Default timeout in milliseconds (optional) */
    timeout?: number;
}
/**
 * Request options for the API layer
 */
export interface TinybirdApiRequestInit extends RequestInit {
    /** Optional token override for a specific request */
    token?: string;
}
export interface TinybirdApiQueryOptions extends QueryOptions {
    /** Optional token override for this request */
    token?: string;
}
export interface TinybirdApiIngestOptions extends IngestOptions {
    /** Optional token override for this request */
    token?: string;
}
export interface TinybirdApiAppendOptions extends Omit<AppendOptions, 'url' | 'file'> {
    /** Optional token override for this request */
    token?: string;
    /** Import mode */
    mode?: "append" | "replace";
}
export interface TinybirdApiDeleteOptions extends Omit<DeleteOptions, 'deleteCondition'> {
    /** Optional token override for this request */
    token?: string;
}
export interface TinybirdApiTruncateOptions extends TruncateOptions {
    /** Optional token override for this request */
    token?: string;
}
/**
 * Scope definition for token creation APIs
 */
export interface TinybirdApiTokenScope {
    type: string;
    resource?: string;
    fixed_params?: Record<string, string | number | boolean>;
    filter?: string;
}
/**
 * Request body for creating Tinybird tokens.
 * Supports JWT-style scopes and static-token scope strings.
 */
export interface TinybirdApiCreateTokenRequest {
    /** Token name/identifier */
    name: string;
    /** JWT-style scopes */
    scopes?: TinybirdApiTokenScope[];
    /** Static-token scope strings */
    scope?: string | string[];
    /** Optional rate-limiting config */
    limits?: {
        rps?: number;
    };
}
/**
 * Options for token creation requests
 */
export interface TinybirdApiCreateTokenOptions {
    /** Optional expiration time for JWT tokens */
    expirationTime?: number;
    /** Optional token override for this request */
    token?: string;
    /** Request timeout in milliseconds */
    timeout?: number;
    /** AbortController signal for cancellation */
    signal?: AbortSignal;
}
/**
 * Result of token creation
 */
export interface TinybirdApiCreateTokenResult {
    token: string;
}
/**
 * Error thrown by TinybirdApi when a response is not OK
 */
export declare class TinybirdApiError extends Error {
    readonly statusCode: number;
    readonly responseBody?: string;
    readonly response?: TinybirdErrorResponse;
    constructor(message: string, statusCode: number, responseBody?: string, response?: TinybirdErrorResponse);
}
/**
 * Low-level Tinybird API wrapper.
 *
 * This layer is intentionally decoupled from the typed TinybirdClient layer
 * so it can be used standalone with just baseUrl + token.
 */
export declare class TinybirdApi {
    private readonly config;
    private readonly baseUrl;
    private readonly defaultToken;
    private readonly fetchFn;
    constructor(config: TinybirdApiConfig);
    /**
     * Execute a request against Tinybird API.
     */
    request(path: string, init?: TinybirdApiRequestInit): Promise<Response>;
    /**
     * Execute a request and parse JSON response.
     */
    requestJson<T = unknown>(path: string, init?: TinybirdApiRequestInit): Promise<T>;
    /**
     * Query a Tinybird endpoint
     */
    query<T = unknown, P extends Record<string, unknown> = Record<string, unknown>>(endpointName: string, params?: P, options?: TinybirdApiQueryOptions): Promise<QueryResult<T>>;
    /**
     * Ingest a single row into a datasource
     */
    ingest<T extends Record<string, unknown>>(datasourceName: string, event: T, options?: TinybirdApiIngestOptions): Promise<IngestResult>;
    /**
     * Ingest a batch of rows into a datasource
     */
    ingestBatch<T extends Record<string, unknown>>(datasourceName: string, events: T[], options?: TinybirdApiIngestOptions): Promise<IngestResult>;
    /**
     * Execute raw SQL against Tinybird
     */
    sql<T = unknown>(sql: string, options?: TinybirdApiQueryOptions): Promise<QueryResult<T>>;
    /**
     * Append data to a datasource from a URL or local file
     */
    appendDatasource(datasourceName: string, options: AppendOptions, apiOptions?: TinybirdApiAppendOptions): Promise<AppendResult>;
    /**
     * Delete rows from a datasource using a SQL condition
     */
    deleteDatasource(datasourceName: string, options: DeleteOptions, apiOptions?: TinybirdApiDeleteOptions): Promise<DeleteResult>;
    /**
     * Truncate all rows from a datasource
     */
    truncateDatasource(datasourceName: string, options?: TruncateOptions, apiOptions?: TinybirdApiTruncateOptions): Promise<TruncateResult>;
    /**
     * Create a token using Tinybird Token API.
     * Supports both static and JWT token payloads.
     */
    createToken(body: TinybirdApiCreateTokenRequest, options?: TinybirdApiCreateTokenOptions): Promise<TinybirdApiCreateTokenResult>;
    /**
     * Detect format from file path or URL extension
     */
    private detectFormat;
    /**
     * Create FormData for file upload
     */
    private createFileFormData;
    private parseOptionalJson;
    private createAbortSignal;
    private resolveIngestMaxRetries;
    private resolveRetry429Delay;
    private resolveRetry503Delay;
    private resolveRetryDelayFromHeaders;
    private parseRetryAfterDelayMs;
    private parseRateLimitResetDelayMs;
    private calculateRetry503DelayMs;
    private discardResponseBody;
    private sleep;
    private serializeEvent;
    private serializeValue;
    private handleErrorResponse;
    private resolveUrl;
}
/**
 * Create a decoupled Tinybird API wrapper.
 */
export declare function createTinybirdApi(config: TinybirdApiConfig): TinybirdApi;
/**
 * Alias for teams that prefer "wrapper" naming.
 */
export declare const createTinybirdApiWrapper: typeof createTinybirdApi;
//# sourceMappingURL=api.d.ts.map