import { RecordBatch } from "apache-arrow";
import * as Schema from "effect/Schema";
export declare const Address: Schema.refine<`0x${string}`, Schema.Schema<string, string, never>>;
export declare const AccessToken: Schema.brand<typeof Schema.NonEmptyTrimmedString, "AccessToken">;
export declare const RefreshToken: Schema.brand<typeof Schema.NonEmptyTrimmedString, "RefreshToken">;
export declare const Network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
export type DatasetNamespace = typeof DatasetNamespace.Type;
export declare const DatasetNamespace: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">;
export type DatasetName = typeof DatasetName.Type;
export declare const DatasetName: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
export type DatasetKind = typeof DatasetKind.Type;
export declare const DatasetKind: Schema.brand<Schema.Literal<["manifest", "evm-rpc", "eth-beacon", "firehose"]>, "DatasetKind">;
export type DatasetVersion = typeof DatasetVersion.Type;
export declare const DatasetVersion: Schema.brand<Schema.refine<string, typeof Schema.String>, "DatasetVersion">;
export type DatasetHash = typeof DatasetHash.Type;
export declare const DatasetHash: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetHash">;
export type DatasetTag = typeof DatasetTag.Type;
export declare const DatasetTag: Schema.brand<Schema.Literal<["latest", "dev"]>, "DatasetTag">;
export type DatasetRevision = typeof DatasetRevision.Type;
export declare const DatasetRevision: Schema.Union<[Schema.brand<Schema.refine<string, typeof Schema.String>, "DatasetVersion">, Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetHash">, Schema.brand<Schema.Literal<["latest", "dev"]>, "DatasetTag">]>;
export type DatasetReferenceString = typeof DatasetReferenceString.Type;
export declare const DatasetReferenceString: Schema.refine<string, typeof Schema.String>;
declare const DatasetReference_base: Schema.Class<DatasetReference, {
    namespace: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">;
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    revision: Schema.Union<[Schema.brand<Schema.refine<string, typeof Schema.String>, "DatasetVersion">, Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetHash">, Schema.brand<Schema.Literal<["latest", "dev"]>, "DatasetTag">]>;
}, Schema.Struct.Encoded<{
    namespace: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">;
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    revision: Schema.Union<[Schema.brand<Schema.refine<string, typeof Schema.String>, "DatasetVersion">, Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetHash">, Schema.brand<Schema.Literal<["latest", "dev"]>, "DatasetTag">]>;
}>, never, {
    readonly namespace: string & import("effect/Brand").Brand<"DatasetNamespace">;
} & {
    readonly name: string & import("effect/Brand").Brand<"DatasetName">;
} & {
    readonly revision: (string & import("effect/Brand").Brand<"DatasetVersion">) | (string & import("effect/Brand").Brand<"DatasetHash">) | (("latest" | "dev") & import("effect/Brand").Brand<"DatasetTag">);
}, {}, {}>;
export declare class DatasetReference extends DatasetReference_base {
    static decode(value: string): DatasetReference;
    encode(this: DatasetReference): string;
}
export declare const DatasetReferenceFromString: Schema.Schema<DatasetReference, string>;
export declare const DatasetNameAndVersion: Schema.Schema<string, string>;
export declare const DatasetRepository: Schema.Schema<URL, string>;
export declare const DatasetReadme: Schema.Schema<string, string>;
export declare const DatasetDescription: Schema.SchemaClass<string, string, never>;
export declare const DatasetKeyword: Schema.SchemaClass<string, string, never>;
export declare const DatasetSource: Schema.SchemaClass<string, string, never>;
export declare const DatasetLicense: Schema.SchemaClass<string, string, never>;
declare const FunctionSource_base: Schema.Class<FunctionSource, {
    source: typeof Schema.String;
    filename: typeof Schema.String;
}, Schema.Struct.Encoded<{
    source: typeof Schema.String;
    filename: typeof Schema.String;
}>, never, {
    readonly source: string;
} & {
    readonly filename: string;
}, {}, {}>;
export declare class FunctionSource extends FunctionSource_base {
}
declare const FunctionDefinition_base: Schema.Class<FunctionDefinition, {
    source: typeof FunctionSource;
    inputTypes: Schema.Array$<typeof Schema.String>;
    outputType: typeof Schema.String;
}, Schema.Struct.Encoded<{
    source: typeof FunctionSource;
    inputTypes: Schema.Array$<typeof Schema.String>;
    outputType: typeof Schema.String;
}>, never, {
    readonly source: FunctionSource;
} & {
    readonly outputType: string;
} & {
    readonly inputTypes: readonly string[];
}, {}, {}>;
export declare class FunctionDefinition extends FunctionDefinition_base {
}
declare const TableDefinition_base: Schema.Class<TableDefinition, {
    sql: typeof Schema.String;
}, Schema.Struct.Encoded<{
    sql: typeof Schema.String;
}>, never, {
    readonly sql: string;
}, {}, {}>;
export declare class TableDefinition extends TableDefinition_base {
}
declare const DatasetMetadata_base: Schema.Class<DatasetMetadata, {
    namespace: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">;
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    readme: Schema.optional<Schema.Schema<string, string, never>>;
    repository: Schema.optional<Schema.Schema<URL, string, never>>;
    description: Schema.optional<Schema.SchemaClass<string, string, never>>;
    keywords: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    sources: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    license: Schema.optional<Schema.SchemaClass<string, string, never>>;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
}, Schema.Struct.Encoded<{
    namespace: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">;
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    readme: Schema.optional<Schema.Schema<string, string, never>>;
    repository: Schema.optional<Schema.Schema<URL, string, never>>;
    description: Schema.optional<Schema.SchemaClass<string, string, never>>;
    keywords: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    sources: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    license: Schema.optional<Schema.SchemaClass<string, string, never>>;
    visibility: Schema.optional<Schema.Literal<["public", "private"]>>;
}>, never, {
    readonly description?: string | undefined;
} & {
    readonly namespace: string & import("effect/Brand").Brand<"DatasetNamespace">;
} & {
    readonly name: string & import("effect/Brand").Brand<"DatasetName">;
} & {
    readonly readme?: string | undefined;
} & {
    readonly repository?: URL | undefined;
} & {
    readonly keywords?: readonly string[] | undefined;
} & {
    readonly sources?: readonly string[] | undefined;
} & {
    readonly license?: string | undefined;
} & {
    readonly visibility?: "public" | "private" | undefined;
}, {}, {}>;
export declare class DatasetMetadata extends DatasetMetadata_base {
}
declare const DatasetConfig_base: Schema.Class<DatasetConfig, {
    namespace: Schema.optional<Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">>;
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    readme: Schema.optional<Schema.Schema<string, string, never>>;
    repository: Schema.optional<Schema.Schema<URL, string, never>>;
    description: Schema.optional<Schema.SchemaClass<string, string, never>>;
    keywords: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    sources: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    license: Schema.optional<Schema.SchemaClass<string, string, never>>;
    private: Schema.optional<typeof Schema.Boolean>;
    dependencies: Schema.Record$<typeof Schema.String, Schema.Schema<DatasetReference, string, never>>;
    tables: Schema.optional<Schema.Record$<typeof Schema.String, typeof TableDefinition>>;
    functions: Schema.optional<Schema.Record$<typeof Schema.String, typeof FunctionDefinition>>;
}, Schema.Struct.Encoded<{
    namespace: Schema.optional<Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetNamespace">>;
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    readme: Schema.optional<Schema.Schema<string, string, never>>;
    repository: Schema.optional<Schema.Schema<URL, string, never>>;
    description: Schema.optional<Schema.SchemaClass<string, string, never>>;
    keywords: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    sources: Schema.optional<Schema.Array$<Schema.SchemaClass<string, string, never>>>;
    license: Schema.optional<Schema.SchemaClass<string, string, never>>;
    private: Schema.optional<typeof Schema.Boolean>;
    dependencies: Schema.Record$<typeof Schema.String, Schema.Schema<DatasetReference, string, never>>;
    tables: Schema.optional<Schema.Record$<typeof Schema.String, typeof TableDefinition>>;
    functions: Schema.optional<Schema.Record$<typeof Schema.String, typeof FunctionDefinition>>;
}>, never, {
    readonly description?: string | undefined;
} & {
    readonly namespace?: (string & import("effect/Brand").Brand<"DatasetNamespace">) | undefined;
} & {
    readonly name: string & import("effect/Brand").Brand<"DatasetName">;
} & {
    readonly readme?: string | undefined;
} & {
    readonly repository?: URL | undefined;
} & {
    readonly keywords?: readonly string[] | undefined;
} & {
    readonly sources?: readonly string[] | undefined;
} & {
    readonly license?: string | undefined;
} & {
    readonly private?: boolean | undefined;
} & {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly dependencies: {
        readonly [x: string]: DatasetReference;
    };
} & {
    readonly tables?: {
        readonly [x: string]: TableDefinition;
    } | undefined;
} & {
    readonly functions?: {
        readonly [x: string]: FunctionDefinition;
    } | undefined;
}, {}, {}>;
export declare class DatasetConfig extends DatasetConfig_base {
}
declare const TableInfo_base: Schema.Class<TableInfo, {
    name: typeof Schema.String;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    activeLocation: Schema.PropertySignature<"?:", string | undefined, "active_location", "?:", string | undefined, false, never>;
}, Schema.Struct.Encoded<{
    name: typeof Schema.String;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    activeLocation: Schema.PropertySignature<"?:", string | undefined, "active_location", "?:", string | undefined, false, never>;
}>, never, {
    readonly name: string;
} & {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly activeLocation?: string | undefined;
}, {}, {}>;
export declare class TableInfo extends TableInfo_base {
}
declare const TableSchemaInfo_base: Schema.Class<TableSchemaInfo, {
    name: typeof Schema.String;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    schema: Schema.Record$<typeof Schema.String, typeof Schema.Any>;
}, Schema.Struct.Encoded<{
    name: typeof Schema.String;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    schema: Schema.Record$<typeof Schema.String, typeof Schema.Any>;
}>, never, {
    readonly name: string;
} & {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly schema: {
        readonly [x: string]: any;
    };
}, {}, {}>;
export declare class TableSchemaInfo extends TableSchemaInfo_base {
}
declare const DatasetInfo_base: Schema.Class<DatasetInfo, {
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    kind: Schema.brand<Schema.Literal<["manifest", "evm-rpc", "eth-beacon", "firehose"]>, "DatasetKind">;
    tables: Schema.Array$<typeof TableInfo>;
}, Schema.Struct.Encoded<{
    name: Schema.brand<Schema.refine<string, Schema.filter<typeof Schema.String>>, "DatasetName">;
    kind: Schema.brand<Schema.Literal<["manifest", "evm-rpc", "eth-beacon", "firehose"]>, "DatasetKind">;
    tables: Schema.Array$<typeof TableInfo>;
}>, never, {
    readonly name: string & import("effect/Brand").Brand<"DatasetName">;
} & {
    readonly tables: readonly TableInfo[];
} & {
    readonly kind: ("manifest" | "evm-rpc" | "eth-beacon" | "firehose") & import("effect/Brand").Brand<"DatasetKind">;
}, {}, {}>;
export declare class DatasetInfo extends DatasetInfo_base {
}
declare const ArrowField_base: Schema.Class<ArrowField, {
    name: typeof Schema.String;
    type: typeof Schema.Any;
    nullable: typeof Schema.Boolean;
}, Schema.Struct.Encoded<{
    name: typeof Schema.String;
    type: typeof Schema.Any;
    nullable: typeof Schema.Boolean;
}>, never, {
    readonly name: string;
} & {
    readonly type: any;
} & {
    readonly nullable: boolean;
}, {}, {}>;
export declare class ArrowField extends ArrowField_base {
}
declare const ArrowSchema_base: Schema.Class<ArrowSchema, {
    fields: Schema.Array$<typeof ArrowField>;
}, Schema.Struct.Encoded<{
    fields: Schema.Array$<typeof ArrowField>;
}>, never, {
    readonly fields: readonly ArrowField[];
}, {}, {}>;
export declare class ArrowSchema extends ArrowSchema_base {
}
declare const TableSchema_base: Schema.Class<TableSchema, {
    arrow: typeof ArrowSchema;
}, Schema.Struct.Encoded<{
    arrow: typeof ArrowSchema;
}>, never, {
    readonly arrow: ArrowSchema;
}, {}, {}>;
export declare class TableSchema extends TableSchema_base {
}
declare const TableInput_base: Schema.Class<TableInput, {
    sql: typeof Schema.String;
}, Schema.Struct.Encoded<{
    sql: typeof Schema.String;
}>, never, {
    readonly sql: string;
}, {}, {}>;
export declare class TableInput extends TableInput_base {
}
declare const Table_base: Schema.Class<Table, {
    input: typeof TableInput;
    schema: typeof TableSchema;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
}, Schema.Struct.Encoded<{
    input: typeof TableInput;
    schema: typeof TableSchema;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly schema: TableSchema;
} & {
    readonly input: TableInput;
}, {}, {}>;
export declare class Table extends Table_base {
}
export declare const RawDatasetTable: Schema.Struct<{
    schema: typeof TableSchema;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
}>;
declare const OutputSchema_base: Schema.Class<OutputSchema, {
    schema: typeof TableSchema;
    networks: Schema.Array$<typeof Schema.String>;
}, Schema.Struct.Encoded<{
    schema: typeof TableSchema;
    networks: Schema.Array$<typeof Schema.String>;
}>, never, {
    readonly schema: TableSchema;
} & {
    readonly networks: readonly string[];
}, {}, {}>;
export declare class OutputSchema extends OutputSchema_base {
}
declare const FunctionManifest_base: Schema.Class<FunctionManifest, {
    name: typeof Schema.String;
    source: typeof FunctionSource;
    inputTypes: Schema.Array$<typeof Schema.String>;
    outputType: typeof Schema.String;
}, Schema.Struct.Encoded<{
    name: typeof Schema.String;
    source: typeof FunctionSource;
    inputTypes: Schema.Array$<typeof Schema.String>;
    outputType: typeof Schema.String;
}>, never, {
    readonly name: string;
} & {
    readonly source: FunctionSource;
} & {
    readonly outputType: string;
} & {
    readonly inputTypes: readonly string[];
}, {}, {}>;
export declare class FunctionManifest extends FunctionManifest_base {
}
declare const DatasetDerived_base: Schema.Class<DatasetDerived, {
    kind: Schema.Literal<["manifest"]>;
    dependencies: Schema.Record$<typeof Schema.String, Schema.Schema<DatasetReference, string, never>>;
    tables: Schema.Record$<typeof Schema.String, typeof Table>;
    functions: Schema.Record$<typeof Schema.String, typeof FunctionManifest>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["manifest"]>;
    dependencies: Schema.Record$<typeof Schema.String, Schema.Schema<DatasetReference, string, never>>;
    tables: Schema.Record$<typeof Schema.String, typeof Table>;
    functions: Schema.Record$<typeof Schema.String, typeof FunctionManifest>;
}>, never, {
    readonly dependencies: {
        readonly [x: string]: DatasetReference;
    };
} & {
    readonly tables: {
        readonly [x: string]: Table;
    };
} & {
    readonly functions: {
        readonly [x: string]: FunctionManifest;
    };
} & {
    readonly kind: "manifest";
}, {}, {}>;
export declare class DatasetDerived extends DatasetDerived_base {
}
declare const DatasetEvmRpc_base: Schema.Class<DatasetEvmRpc, {
    kind: Schema.Literal<["evm-rpc"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    startBlock: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalizedBlocksOnly: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    }>>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["evm-rpc"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    startBlock: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalizedBlocksOnly: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    }>>;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly tables: {
        readonly [x: string]: {
            readonly network: string & import("effect/Brand").Brand<"Network">;
            readonly schema: TableSchema;
        };
    };
} & {
    readonly kind: "evm-rpc";
} & {
    readonly startBlock?: number | undefined;
} & {
    readonly finalizedBlocksOnly?: boolean | undefined;
}, {}, {}>;
export declare class DatasetEvmRpc extends DatasetEvmRpc_base {
}
declare const DatasetEthBeacon_base: Schema.Class<DatasetEthBeacon, {
    kind: Schema.Literal<["eth-beacon"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    startBlock: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalizedBlocksOnly: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    }>>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["eth-beacon"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    startBlock: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalizedBlocksOnly: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    }>>;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly tables: {
        readonly [x: string]: {
            readonly network: string & import("effect/Brand").Brand<"Network">;
            readonly schema: TableSchema;
        };
    };
} & {
    readonly kind: "eth-beacon";
} & {
    readonly startBlock?: number | undefined;
} & {
    readonly finalizedBlocksOnly?: boolean | undefined;
}, {}, {}>;
export declare class DatasetEthBeacon extends DatasetEthBeacon_base {
}
declare const DatasetFirehose_base: Schema.Class<DatasetFirehose, {
    kind: Schema.Literal<["firehose"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    startBlock: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalizedBlocksOnly: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    }>>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["firehose"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    startBlock: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalizedBlocksOnly: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    }>>;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly tables: {
        readonly [x: string]: {
            readonly network: string & import("effect/Brand").Brand<"Network">;
            readonly schema: TableSchema;
        };
    };
} & {
    readonly kind: "firehose";
} & {
    readonly startBlock?: number | undefined;
} & {
    readonly finalizedBlocksOnly?: boolean | undefined;
}, {}, {}>;
export declare class DatasetFirehose extends DatasetFirehose_base {
}
/**
 * Union type representing any dataset manifest kind.
 *
 * This type is used at API boundaries (registration, storage, retrieval).
 * Metadata (namespace, name, version) is passed separately to the API.
 *
 * Supported kinds:
 * - DatasetDerived (kind: "manifest") - SQL-based derived datasets
 * - DatasetEvmRpc (kind: "evm-rpc") - EVM RPC extraction datasets
 * - DatasetEthBeacon (kind: "eth-beacon") - ETH beacon extraction datasets
 * - DatasetFirehose (kind: "firehose") - Firehose extraction datasets
 */
export declare const DatasetManifest: Schema.Union<[typeof DatasetDerived, typeof DatasetEvmRpc, typeof DatasetEthBeacon, typeof DatasetFirehose]>;
export type DatasetManifest = Schema.Schema.Type<typeof DatasetManifest>;
declare const EvmRpcProvider_base: Schema.Class<EvmRpcProvider, {
    kind: Schema.Literal<["evm-rpc"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    url: typeof Schema.URL;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["evm-rpc"]>;
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    url: typeof Schema.URL;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly kind: "evm-rpc";
} & {
    readonly url: URL;
}, {}, {}>;
export declare class EvmRpcProvider extends EvmRpcProvider_base {
}
export declare const Provider: Schema.SchemaClass<EvmRpcProvider, {
    readonly network: string;
    readonly kind: "evm-rpc";
    readonly url: string;
}, never>;
export declare const JobId: Schema.SchemaClass<number, number, never>;
export declare const JobStatus: Schema.Literal<["SCHEDULED", "RUNNING", "COMPLETED", "STOPPED", "STOP_REQUESTED", "STOPPING", "FAILED", "UNKNOWN"]>;
export declare const JobIdParam: Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.Number, never>;
declare const JobInfo_base: Schema.Class<JobInfo, {
    id: Schema.SchemaClass<number, number, never>;
    createdAt: Schema.PropertySignature<":", import("effect/DateTime").Utc, "created_at", ":", string, false, never>;
    updatedAt: Schema.PropertySignature<":", import("effect/DateTime").Utc, "updated_at", ":", string, false, never>;
    nodeId: Schema.PropertySignature<":", string, "node_id", ":", string, false, never>;
    status: Schema.Literal<["SCHEDULED", "RUNNING", "COMPLETED", "STOPPED", "STOP_REQUESTED", "STOPPING", "FAILED", "UNKNOWN"]>;
    descriptor: typeof Schema.Any;
}, Schema.Struct.Encoded<{
    id: Schema.SchemaClass<number, number, never>;
    createdAt: Schema.PropertySignature<":", import("effect/DateTime").Utc, "created_at", ":", string, false, never>;
    updatedAt: Schema.PropertySignature<":", import("effect/DateTime").Utc, "updated_at", ":", string, false, never>;
    nodeId: Schema.PropertySignature<":", string, "node_id", ":", string, false, never>;
    status: Schema.Literal<["SCHEDULED", "RUNNING", "COMPLETED", "STOPPED", "STOP_REQUESTED", "STOPPING", "FAILED", "UNKNOWN"]>;
    descriptor: typeof Schema.Any;
}>, never, {
    readonly id: number;
} & {
    readonly status: "SCHEDULED" | "RUNNING" | "COMPLETED" | "STOPPED" | "STOP_REQUESTED" | "STOPPING" | "FAILED" | "UNKNOWN";
} & {
    readonly descriptor: any;
} & {
    readonly createdAt: import("effect/DateTime").Utc;
} & {
    readonly updatedAt: import("effect/DateTime").Utc;
} & {
    readonly nodeId: string;
}, {}, {}>;
export declare class JobInfo extends JobInfo_base {
}
export declare const BlockNumber: Schema.brand<Schema.refine<number, typeof Schema.NonNegative>, "BlockNumber">;
declare const BlockRange_base: Schema.Class<BlockRange, {
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    numbers: Schema.Struct<{
        start: typeof Schema.Number;
        end: typeof Schema.Number;
    }>;
    hash: typeof Schema.String;
    prevHash: Schema.optional<typeof Schema.String>;
}, Schema.Struct.Encoded<{
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    numbers: Schema.Struct<{
        start: typeof Schema.Number;
        end: typeof Schema.Number;
    }>;
    hash: typeof Schema.String;
    prevHash: Schema.optional<typeof Schema.String>;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly hash: string;
} & {
    readonly numbers: {
        readonly start: number;
        readonly end: number;
    };
} & {
    readonly prevHash?: string | undefined;
}, {}, {}>;
export declare class BlockRange extends BlockRange_base {
}
export type BlockRanges = typeof BlockRanges.Type;
export declare const BlockRanges: Schema.Array$<typeof BlockRange>;
declare const InvalidationRange_base: Schema.Class<InvalidationRange, {
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    numbers: Schema.Struct<{
        start: Schema.brand<Schema.refine<number, typeof Schema.NonNegative>, "BlockNumber">;
        end: Schema.brand<Schema.refine<number, typeof Schema.NonNegative>, "BlockNumber">;
    }>;
}, Schema.Struct.Encoded<{
    network: Schema.brand<Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>, "Network">;
    numbers: Schema.Struct<{
        start: Schema.brand<Schema.refine<number, typeof Schema.NonNegative>, "BlockNumber">;
        end: Schema.brand<Schema.refine<number, typeof Schema.NonNegative>, "BlockNumber">;
    }>;
}>, never, {
    readonly network: string & import("effect/Brand").Brand<"Network">;
} & {
    readonly numbers: {
        readonly start: number & import("effect/Brand").Brand<"BlockNumber">;
        readonly end: number & import("effect/Brand").Brand<"BlockNumber">;
    };
}, {}, {}>;
/**
 * Invalidation range for reorgs.
 */
export declare class InvalidationRange extends InvalidationRange_base {
}
export type InvalidationRanges = typeof InvalidationRanges.Type;
export declare const InvalidationRanges: Schema.Array$<typeof InvalidationRange>;
declare const RecordBatchMetadata_base: Schema.Class<RecordBatchMetadata, {
    ranges: Schema.Array$<typeof BlockRange>;
    rangesComplete: Schema.PropertySignature<":", boolean, "ranges_complete", ":", boolean, false, never>;
}, Schema.Struct.Encoded<{
    ranges: Schema.Array$<typeof BlockRange>;
    rangesComplete: Schema.PropertySignature<":", boolean, "ranges_complete", ":", boolean, false, never>;
}>, never, {
    readonly ranges: readonly BlockRange[];
} & {
    readonly rangesComplete: boolean;
}, {}, {}>;
export declare class RecordBatchMetadata extends RecordBatchMetadata_base {
}
export declare const parseRecordBatchMetadata: <A, R>(from: Schema.Schema<Uint8Array, A, R>) => Schema.Schema<RecordBatchMetadata, A, R>;
export declare const RecordBatchMetadataFromFlight: Schema.Schema<RecordBatchMetadata, Uint8Array<ArrayBufferLike>, never>;
export declare const GenrateTokenDuration: Schema.filter<typeof Schema.String>;
export type GenrateTokenDuration = typeof GenrateTokenDuration.Type;
declare const TableSchemaWithNetworks_base: Schema.Class<TableSchemaWithNetworks, {
    schema: typeof TableSchema;
    networks: Schema.Array$<typeof Schema.String>;
}, Schema.Struct.Encoded<{
    schema: typeof TableSchema;
    networks: Schema.Array$<typeof Schema.String>;
}>, never, {
    readonly schema: TableSchema;
} & {
    readonly networks: readonly string[];
}, {}, {}>;
export declare class TableSchemaWithNetworks extends TableSchemaWithNetworks_base {
}
export declare const RecordBatchFromSelf: Schema.declare<RecordBatch<any>, RecordBatch<any>, readonly [], never>;
export declare const RecordBatchFromUint8Array: Schema.Schema<RecordBatch<any>, Uint8Array<ArrayBufferLike>, never>;
declare const ResponseBatch_base: Schema.TaggedClass<ResponseBatch, "ResponseBatch", {
    readonly _tag: Schema.tag<"ResponseBatch">;
} & {
    data: Schema.Schema<RecordBatch<any>, Uint8Array<ArrayBufferLike>, never>;
    metadata: typeof RecordBatchMetadata;
}>;
/**
 * A record batch with metadata.
 */
export declare class ResponseBatch extends ResponseBatch_base {
}
export {};
//# sourceMappingURL=Model.d.ts.map