/**
 * Project definition for Tinybird
 * Aggregates all datasources and pipes into a single schema
 */
import type { DatasourceDefinition, SchemaDefinition } from "./datasource.js";
import type { PipeDefinition, ParamsDefinition, OutputDefinition } from "./pipe.js";
import type { ConnectionDefinition } from "./connection.js";
import type { TinybirdClient } from "../client/base.js";
import type { AppendOptions, AppendResult, DatasourcesNamespace, DeleteOptions, DeleteResult, IngestOptions, IngestResult, QueryOptions, QueryResult, TruncateOptions, TruncateResult } from "../client/types.js";
import type { InferRow, InferParams, InferOutputRow } from "../infer/index.js";
import type { TokensNamespace } from "../client/tokens.js";
declare const PROJECT_BRAND: unique symbol;
/**
 * Collection of datasource definitions
 */
export type DatasourcesDefinition = Record<string, DatasourceDefinition<SchemaDefinition>>;
/**
 * Collection of pipe definitions
 */
export type PipesDefinition = Record<string, PipeDefinition<ParamsDefinition, OutputDefinition>>;
/**
 * Collection of connection definitions
 */
export type ConnectionsDefinition = Record<string, ConnectionDefinition>;
/**
 * Type for a single query method
 */
type QueryMethod<T extends PipeDefinition<ParamsDefinition, OutputDefinition>> = T extends PipeDefinition<infer P, OutputDefinition> ? keyof P extends never ? () => Promise<QueryResult<InferOutputRow<T>>> : (params: InferParams<T>) => Promise<QueryResult<InferOutputRow<T>>> : never;
/**
 * Type for pipe entity accessors object
 * Note: At runtime, all declared pipes are included. Non-endpoint pipes throw
 * when queried with a clear error message.
 */
type PipeEntityAccessors<T extends PipesDefinition> = {
    [K in keyof T]: {
        query: QueryMethod<T[K]>;
    };
};
/**
 * Type for a datasource accessor with import/mutation methods
 */
type DatasourceAccessor<T extends DatasourceDefinition<SchemaDefinition>> = {
    /** Ingest a single event row */
    ingest(event: InferRow<T>): Promise<IngestResult>;
    /** Ingest multiple event rows in a batch */
    ingestBatch(events: InferRow<T>[], options?: IngestOptions): Promise<IngestResult>;
    /** Append data from a URL or file */
    append(options: AppendOptions): Promise<AppendResult>;
    /** Replace datasource content from a URL or file */
    replace(options: AppendOptions): Promise<AppendResult>;
    /** Delete rows using a SQL condition */
    delete(options: DeleteOptions): Promise<DeleteResult>;
    /** Truncate all rows */
    truncate(options?: TruncateOptions): Promise<TruncateResult>;
};
/**
 * Type for datasource accessors object
 * Maps each datasource to an accessor with import/mutation methods
 */
type DatasourceAccessors<T extends DatasourcesDefinition> = {
    [K in keyof T]: DatasourceAccessor<T[K]>;
};
/**
 * Base project client interface
 */
interface ProjectClientBase {
    /** Token operations (JWT creation, etc.) */
    readonly tokens: TokensNamespace;
    /** Datasource operations (ingest/append/replace/delete/truncate) */
    readonly datasources: DatasourcesNamespace;
    /** Execute raw SQL queries */
    sql<T = unknown>(sql: string, options?: QueryOptions): Promise<QueryResult<T>>;
    /** Raw client for advanced usage */
    readonly client: TinybirdClient;
}
/**
 * Typed client interface for a project
 * Includes datasource accessors as top-level properties
 */
export type ProjectClient<TDatasources extends DatasourcesDefinition, TPipes extends PipesDefinition> = ProjectClientBase & DatasourceAccessors<TDatasources> & PipeEntityAccessors<TPipes>;
/**
 * Configuration for createTinybirdClient
 */
export interface TinybirdClientConfig<TDatasources extends DatasourcesDefinition = DatasourcesDefinition, TPipes extends PipesDefinition = PipesDefinition> {
    /** All datasources */
    datasources: TDatasources;
    /** All pipes */
    pipes: TPipes;
    /** Tinybird API base URL (defaults to TINYBIRD_URL env var or https://api.tinybird.co) */
    baseUrl?: string;
    /** Tinybird API token (defaults to TINYBIRD_TOKEN env var) */
    token?: string;
    /** Custom fetch implementation (optional, defaults to global fetch) */
    fetch?: typeof fetch;
    /**
     * Directory to use as the starting point when searching for tinybird.json config.
     * In monorepo setups, this should be set to the directory containing tinybird.json
     * to ensure the config is found regardless of where the application runs from.
     */
    configDir?: string;
    /**
     * Enable development mode for the client.
     * Defaults to `process.env.NODE_ENV === "development"` if not specified.
     */
    devMode?: boolean;
}
/**
 * Project configuration
 */
export interface ProjectConfig<TDatasources extends DatasourcesDefinition = DatasourcesDefinition, TPipes extends PipesDefinition = PipesDefinition, TConnections extends ConnectionsDefinition = ConnectionsDefinition> {
    /** All datasources in this project */
    datasources?: TDatasources;
    /** All pipes in this project */
    pipes?: TPipes;
    /** All connections in this project */
    connections?: TConnections;
}
/**
 * A project definition with full type information
 */
export interface ProjectDefinition<TDatasources extends DatasourcesDefinition = DatasourcesDefinition, TPipes extends PipesDefinition = PipesDefinition, TConnections extends ConnectionsDefinition = ConnectionsDefinition> {
    readonly [PROJECT_BRAND]: true;
    /** Type marker for inference */
    readonly _type: "project";
    /** All datasources */
    readonly datasources: TDatasources;
    /** All pipes */
    readonly pipes: TPipes;
    /** All connections */
    readonly connections: TConnections;
    /** Typed Tinybird client */
    readonly tinybird: ProjectClient<TDatasources, TPipes>;
}
/**
 * Define a Tinybird project
 *
 * This aggregates all datasources and pipes into a single schema definition
 * that can be used for code generation and type inference.
 *
 * @param config - Project configuration with datasources and pipes
 * @returns A project definition
 *
 * @example
 * ```ts
 * // tinybird/schema.ts
 * import { defineProject } from '@tinybirdco/sdk';
 * import { events, users } from './datasources';
 * import { topEvents, userActivity } from './pipes';
 *
 * export default defineProject({
 *   datasources: {
 *     events,
 *     users,
 *   },
 *   pipes: {
 *     topEvents,
 *     userActivity,
 *   },
 * });
 * ```
 */
export declare function defineProject<TDatasources extends DatasourcesDefinition, TPipes extends PipesDefinition, TConnections extends ConnectionsDefinition>(config: ProjectConfig<TDatasources, TPipes, TConnections>): ProjectDefinition<TDatasources, TPipes, TConnections>;
/**
 * Check if a value is a project definition
 */
export declare function isProjectDefinition(value: unknown): value is ProjectDefinition;
/**
 * Constructor interface for Tinybird class
 * This allows TypeScript to infer the correct return type with typed accessors
 */
interface TinybirdConstructor {
    new <TDatasources extends DatasourcesDefinition, TPipes extends PipesDefinition>(config: TinybirdClientConfig<TDatasources, TPipes>): ProjectClient<TDatasources, TPipes>;
}
/**
 * Typed Tinybird client
 *
 * Creates a client with typed pipe query and datasource methods based on
 * the provided datasources and pipes.
 *
 * @example
 * ```ts
 * import { Tinybird } from '@tinybirdco/sdk';
 * import { pageViews, events } from './datasources';
 * import { topPages } from './pipes';
 *
 * export const tinybird = new Tinybird({
 *   datasources: { pageViews, events },
 *   pipes: { topPages },
 * });
 *
 * // Query a pipe (fully typed)
 * const result = await tinybird.topPages.query({
 *   start_date: '2024-01-01 00:00:00',
 *   end_date: '2024-01-31 23:59:59',
 * });
 *
 * // Ingest an event (fully typed)
 * await tinybird.pageViews.ingest({
 *   timestamp: '2024-01-15 10:30:00',
 *   pathname: '/home',
 *   session_id: 'abc123',
 * });
 * ```
 */
export declare const Tinybird: TinybirdConstructor;
/**
 * Create a typed Tinybird client
 *
 * @deprecated Use `new Tinybird(...)` instead. This function is kept for backward compatibility.
 *
 * @param config - Client configuration with datasources and pipes
 * @returns A typed client with pipe query and datasource methods
 */
export declare function createTinybirdClient<TDatasources extends DatasourcesDefinition, TPipes extends PipesDefinition>(config: TinybirdClientConfig<TDatasources, TPipes>): ProjectClient<TDatasources, TPipes>;
/**
 * Get all datasource names from a project
 */
export declare function getDatasourceNames<T extends ProjectDefinition>(project: T): (keyof T["datasources"])[];
/**
 * Get all pipe names from a project
 */
export declare function getPipeNames<T extends ProjectDefinition>(project: T): (keyof T["pipes"])[];
/**
 * Get a datasource by name from a project
 */
export declare function getDatasource<TDatasources extends DatasourcesDefinition, TPipes extends PipesDefinition, K extends keyof TDatasources>(project: ProjectDefinition<TDatasources, TPipes>, name: K): TDatasources[K];
/**
 * Get a pipe by name from a project
 */
export declare function getPipe<TDatasources extends DatasourcesDefinition, TPipes extends PipesDefinition, K extends keyof TPipes>(project: ProjectDefinition<TDatasources, TPipes>, name: K): TPipes[K];
/**
 * Helper type to extract datasources from a project
 */
export type ExtractDatasources<T> = T extends ProjectDefinition<infer D, PipesDefinition> ? D : never;
/**
 * Helper type to extract pipes from a project
 */
export type ExtractPipes<T> = T extends ProjectDefinition<DatasourcesDefinition, infer P> ? P : never;
/**
 * Data model type derived from a project
 * Useful for generating typed clients
 */
export type DataModel<T extends ProjectDefinition> = {
    datasources: {
        [K in keyof T["datasources"]]: T["datasources"][K] extends DatasourceDefinition<infer S> ? S : never;
    };
    pipes: {
        [K in keyof T["pipes"]]: T["pipes"][K] extends PipeDefinition<infer P, infer O> ? {
            params: P;
            output: O;
        } : never;
    };
};
export {};
//# sourceMappingURL=project.d.ts.map