import { z } from 'zod';

declare const pipeResponseWithoutData: z.ZodObject<{
    meta: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodString;
    }, z.core.$strip>>;
    rows: z.ZodOptional<z.ZodNumber>;
    rows_before_limit_at_least: z.ZodOptional<z.ZodNumber>;
    statistics: z.ZodOptional<z.ZodObject<{
        elapsed: z.ZodOptional<z.ZodNumber>;
        rows_read: z.ZodOptional<z.ZodNumber>;
        bytes_read: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;
declare const eventIngestReponseData: z.ZodObject<{
    successful_rows: z.ZodNumber;
    quarantined_rows: z.ZodNumber;
}, z.core.$strip>;

type Config = {
    baseUrl?: string;
} & ({
    token: string;
    noop?: never;
} | {
    token?: never;
    noop: true;
});
declare class Tinybird {
    private readonly baseUrl;
    private readonly token;
    private readonly noop;
    constructor(config: Config);
    private fetch;
    buildPipe<TParameters extends z.ZodSchema<any>, TData extends z.ZodSchema<any>>(req: {
        pipe: string;
        parameters?: TParameters;
        data: TData;
        opts?: {
            cache?: RequestCache;
            next?: {
                /**
                 * Number of seconds to revalidate the cache (nextjs specific)
                 */
                revalidate?: number;
            };
        };
    }): (params: z.input<TParameters>) => Promise<z.infer<typeof pipeResponseWithoutData> & {
        data: z.output<TData>[];
    }>;
    buildIngestEndpoint<TSchema extends z.ZodSchema<any>>(req: {
        datasource: string;
        event: TSchema;
        wait?: boolean;
    }): (events: z.input<TSchema> | z.input<TSchema>[]) => Promise<z.infer<typeof eventIngestReponseData>>;
}

/**
 * NoopTinybird is a mock implementation of the Tinybird client that doesn't do anything and returns empty data.
 */
declare class NoopTinybird extends Tinybird {
    constructor();
}

export { type Config, NoopTinybird, Tinybird };