import * as Effect from "effect/Effect";
import type * as ParseResult from "effect/ParseResult";
import * as Schema from "effect/Schema";
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 {
}
export declare const DEFAULT_NAMESPACE = "_";
export declare const DatasetNamespace: Schema.refine<string, Schema.filter<typeof Schema.String>>;
export type DatasetNamespace = Schema.Schema.Type<typeof DatasetNamespace>;
export declare const DatasetName: Schema.refine<string, Schema.filter<typeof Schema.String>>;
export type DatasetName = Schema.Schema.Type<typeof DatasetName>;
export declare const Network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
export declare const DatasetKind: Schema.Literal<["manifest", "evm-rpc", "eth-beacon", "firehose"]>;
export declare const DatasetVersion: Schema.refine<string, typeof Schema.String>;
export type DatasetVersion = Schema.Schema.Type<typeof DatasetVersion>;
export declare const DatasetHash: Schema.refine<string, Schema.filter<typeof Schema.String>>;
export type DatasetHash = Schema.Schema.Type<typeof DatasetHash>;
export declare const DatasetLatestTag: Schema.Literal<["latest"]>;
export type DatasetLatestTag = Schema.Schema.Type<typeof DatasetLatestTag>;
export declare const DatasetDevTag: Schema.Literal<["dev"]>;
export type DatasetDevTag = Schema.Schema.Type<typeof DatasetDevTag>;
export declare const DatasetRevision: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.refine<string, Schema.filter<typeof Schema.String>>, Schema.Literal<["latest"]>, Schema.Literal<["dev"]>]>;
export type DatasetRevision = Schema.Schema.Type<typeof DatasetRevision>;
export declare const DatasetReferenceStr: Schema.refine<string, typeof Schema.String>;
export type DatasetReferenceStr = Schema.Schema.Type<typeof DatasetReferenceStr>;
declare const DatasetReference_base: Schema.Class<DatasetReference, {
    namespace: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    revision: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.refine<string, Schema.filter<typeof Schema.String>>, Schema.Literal<["latest"]>, Schema.Literal<["dev"]>]>;
}, Schema.Struct.Encoded<{
    namespace: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    revision: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.refine<string, Schema.filter<typeof Schema.String>>, Schema.Literal<["latest"]>, Schema.Literal<["dev"]>]>;
}>, never, {
    readonly name: string;
} & {
    readonly namespace: string;
} & {
    readonly revision: string;
}, {}, {}>;
export declare class DatasetReference extends DatasetReference_base {
}
/**
 * Parses a dataset reference string to extract and validate namespace, name, and revision components.
 *
 * @param reference - The reference string to parse in format "namespace/name@revision"
 * @returns An Effect that yields a DatasetReference instance
 *
 * @example
 * const ref = yield* parseDatasetReference("edgeandnode/mainnet@1.0.0")
 * // DatasetReference { namespace: "edgeandnode", name: "mainnet", revision: "1.0.0" }
 *
 * const ref = yield* parseDatasetReference("edgeandnode/mainnet@latest")
 * // DatasetReference { namespace: "edgeandnode", name: "mainnet", revision: "latest" }
 */
export declare const parseDatasetReference: (reference: DatasetReferenceStr) => Effect.Effect<DatasetReference, ParseResult.ParseError>;
export declare const DatasetNameAndVersion: Schema.refine<`${string}@${string}`, Schema.TemplateLiteral<`${string}@${string}`>>;
export declare const DatasetRepository: Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.URLFromSelf, never>;
export declare const DatasetReadme: 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 DatasetMetadata_base: Schema.Class<DatasetMetadata, {
    namespace: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    readme: Schema.optional<Schema.SchemaClass<string, string, never>>;
    repository: Schema.optional<Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.URLFromSelf, never>>;
}, Schema.Struct.Encoded<{
    namespace: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    readme: Schema.optional<Schema.SchemaClass<string, string, never>>;
    repository: Schema.optional<Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.URLFromSelf, never>>;
}>, never, {
    readonly name: string;
} & {
    readonly namespace: string;
} & {
    readonly readme?: string | undefined;
} & {
    readonly repository?: URL | undefined;
}, {}, {}>;
export declare class DatasetMetadata extends DatasetMetadata_base {
}
declare const DatasetConfig_base: Schema.Class<DatasetConfig, {
    namespace: Schema.optional<Schema.refine<string, Schema.filter<typeof Schema.String>>>;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    readme: Schema.optional<Schema.SchemaClass<string, string, never>>;
    repository: Schema.optional<Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.URLFromSelf, never>>;
    dependencies: Schema.Record$<typeof Schema.String, Schema.refine<string, typeof Schema.String>>;
    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.refine<string, Schema.filter<typeof Schema.String>>>;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    readme: Schema.optional<Schema.SchemaClass<string, string, never>>;
    repository: Schema.optional<Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.URLFromSelf, never>>;
    dependencies: Schema.Record$<typeof Schema.String, Schema.refine<string, typeof Schema.String>>;
    tables: Schema.optional<Schema.Record$<typeof Schema.String, typeof TableDefinition>>;
    functions: Schema.optional<Schema.Record$<typeof Schema.String, typeof FunctionDefinition>>;
}>, never, {
    readonly name: string;
} & {
    readonly namespace?: string | undefined;
} & {
    readonly readme?: string | undefined;
} & {
    readonly repository?: URL | undefined;
} & {
    readonly network: string;
} & {
    readonly dependencies: {
        readonly [x: string]: string;
    };
} & {
    readonly tables?: {
        readonly [x: string]: TableDefinition;
    } | undefined;
} & {
    readonly functions?: {
        readonly [x: string]: FunctionDefinition;
    } | undefined;
}, {}, {}>;
export declare class DatasetConfig extends DatasetConfig_base {
}
export declare const DatasetDefinition: typeof DatasetConfig;
declare const TableInfo_base: Schema.Class<TableInfo, {
    name: typeof Schema.String;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    activeLocation: Schema.PropertySignature<"?:", string | undefined, "active_location", "?:", string | undefined, false, never>;
}, Schema.Struct.Encoded<{
    name: typeof Schema.String;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    activeLocation: Schema.PropertySignature<"?:", string | undefined, "active_location", "?:", string | undefined, false, never>;
}>, never, {
    readonly name: string;
} & {
    readonly network: string;
} & {
    readonly activeLocation?: string | undefined;
}, {}, {}>;
export declare class TableInfo extends TableInfo_base {
}
declare const TableSchemaInfo_base: Schema.Class<TableSchemaInfo, {
    name: typeof Schema.String;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    schema: Schema.Record$<typeof Schema.String, typeof Schema.Any>;
}, Schema.Struct.Encoded<{
    name: typeof Schema.String;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    schema: Schema.Record$<typeof Schema.String, typeof Schema.Any>;
}>, never, {
    readonly name: string;
} & {
    readonly network: string;
} & {
    readonly schema: {
        readonly [x: string]: any;
    };
}, {}, {}>;
export declare class TableSchemaInfo extends TableSchemaInfo_base {
}
declare const DatasetInfo_base: Schema.Class<DatasetInfo, {
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    kind: Schema.Literal<["manifest", "evm-rpc", "eth-beacon", "firehose"]>;
    tables: Schema.Array$<typeof TableInfo>;
}, Schema.Struct.Encoded<{
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    kind: Schema.Literal<["manifest", "evm-rpc", "eth-beacon", "firehose"]>;
    tables: Schema.Array$<typeof TableInfo>;
}>, never, {
    readonly name: string;
} & {
    readonly tables: readonly TableInfo[];
} & {
    readonly kind: "manifest" | "evm-rpc" | "eth-beacon" | "firehose";
}, {}, {}>;
export declare class DatasetInfo extends DatasetInfo_base {
}
declare const DatasetVersionInfo_base: Schema.Class<DatasetVersionInfo, {
    namespace: typeof Schema.String;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    revision: typeof Schema.String;
    manifestHash: Schema.PropertySignature<":", string, "manifest_hash", ":", string, false, never>;
    kind: typeof Schema.String;
}, Schema.Struct.Encoded<{
    namespace: typeof Schema.String;
    name: Schema.refine<string, Schema.filter<typeof Schema.String>>;
    revision: typeof Schema.String;
    manifestHash: Schema.PropertySignature<":", string, "manifest_hash", ":", string, false, never>;
    kind: typeof Schema.String;
}>, never, {
    readonly name: string;
} & {
    readonly namespace: string;
} & {
    readonly revision: string;
} & {
    readonly kind: string;
} & {
    readonly manifestHash: string;
}, {}, {}>;
export declare class DatasetVersionInfo extends DatasetVersionInfo_base {
}
declare const DatasetSummary_base: Schema.Class<DatasetSummary, {
    namespace: typeof Schema.String;
    name: typeof Schema.String;
    latestVersion: Schema.PropertySignature<"?:", string | undefined, "latest_version", "?:", string | undefined, false, never>;
    versions: Schema.Array$<typeof Schema.String>;
}, Schema.Struct.Encoded<{
    namespace: typeof Schema.String;
    name: typeof Schema.String;
    latestVersion: Schema.PropertySignature<"?:", string | undefined, "latest_version", "?:", string | undefined, false, never>;
    versions: Schema.Array$<typeof Schema.String>;
}>, never, {
    readonly name: string;
} & {
    readonly namespace: string;
} & {
    readonly latestVersion?: string | undefined;
} & {
    readonly versions: readonly string[];
}, {}, {}>;
export declare class DatasetSummary extends DatasetSummary_base {
}
declare const DatasetsResponse_base: Schema.Class<DatasetsResponse, {
    datasets: Schema.Array$<typeof DatasetSummary>;
}, Schema.Struct.Encoded<{
    datasets: Schema.Array$<typeof DatasetSummary>;
}>, never, {
    readonly datasets: readonly DatasetSummary[];
}, {}, {}>;
export declare class DatasetsResponse extends DatasetsResponse_base {
}
declare const DatasetVersionsResponse_base: Schema.Class<DatasetVersionsResponse, {
    versions: Schema.Array$<Schema.refine<string, typeof Schema.String>>;
}, Schema.Struct.Encoded<{
    versions: Schema.Array$<Schema.refine<string, typeof Schema.String>>;
}>, never, {
    readonly versions: readonly string[];
}, {}, {}>;
/**
 * Response for listing versions of a specific dataset
 */
export declare class DatasetVersionsResponse extends DatasetVersionsResponse_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 type: any;
} & {
    readonly name: string;
} & {
    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.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
}, Schema.Struct.Encoded<{
    input: typeof TableInput;
    schema: typeof TableSchema;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
}>, never, {
    readonly input: TableInput;
} & {
    readonly network: string;
} & {
    readonly schema: TableSchema;
}, {}, {}>;
export declare class Table extends Table_base {
}
export declare const RawDatasetTable: Schema.Struct<{
    schema: typeof TableSchema;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
}>;
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.refine<string, typeof Schema.String>>;
    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.refine<string, typeof Schema.String>>;
    tables: Schema.Record$<typeof Schema.String, typeof Table>;
    functions: Schema.Record$<typeof Schema.String, typeof FunctionManifest>;
}>, never, {
    readonly dependencies: {
        readonly [x: string]: string;
    };
} & {
    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.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    start_block: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalized_blocks_only: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    }>>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["evm-rpc"]>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    start_block: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalized_blocks_only: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    }>>;
}>, never, {
    readonly network: string;
} & {
    readonly tables: {
        readonly [x: string]: {
            readonly network: string;
            readonly schema: TableSchema;
        };
    };
} & {
    readonly kind: "evm-rpc";
} & {
    readonly start_block?: number | undefined;
} & {
    readonly finalized_blocks_only?: boolean | undefined;
}, {}, {}>;
export declare class DatasetEvmRpc extends DatasetEvmRpc_base {
}
declare const DatasetEthBeacon_base: Schema.Class<DatasetEthBeacon, {
    kind: Schema.Literal<["eth-beacon"]>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    start_block: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalized_blocks_only: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    }>>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["eth-beacon"]>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    start_block: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalized_blocks_only: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    }>>;
}>, never, {
    readonly network: string;
} & {
    readonly tables: {
        readonly [x: string]: {
            readonly network: string;
            readonly schema: TableSchema;
        };
    };
} & {
    readonly kind: "eth-beacon";
} & {
    readonly start_block?: number | undefined;
} & {
    readonly finalized_blocks_only?: boolean | undefined;
}, {}, {}>;
export declare class DatasetEthBeacon extends DatasetEthBeacon_base {
}
declare const DatasetFirehose_base: Schema.Class<DatasetFirehose, {
    kind: Schema.Literal<["firehose"]>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    start_block: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalized_blocks_only: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    }>>;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["firehose"]>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    start_block: Schema.PropertySignature<"?:", number | undefined, "start_block", "?:", number | undefined, false, never>;
    finalized_blocks_only: Schema.PropertySignature<"?:", boolean | undefined, "finalized_blocks_only", "?:", boolean | undefined, false, never>;
    tables: Schema.Record$<typeof Schema.String, Schema.Struct<{
        schema: typeof TableSchema;
        network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    }>>;
}>, never, {
    readonly network: string;
} & {
    readonly tables: {
        readonly [x: string]: {
            readonly network: string;
            readonly schema: TableSchema;
        };
    };
} & {
    readonly kind: "firehose";
} & {
    readonly start_block?: number | undefined;
} & {
    readonly finalized_blocks_only?: 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
 *
 * Future kinds: DatasetFirehose, DatasetEthBeacon, etc.
 */
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.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    url: typeof Schema.URL;
}, Schema.Struct.Encoded<{
    kind: Schema.Literal<["evm-rpc"]>;
    network: Schema.transform<Schema.SchemaClass<string, string, never>, typeof Schema.Lowercased>;
    url: typeof Schema.URL;
}>, never, {
    readonly network: string;
} & {
    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<["RUNNING", "TERMINAL", "COMPLETED", "STOPPED", "ERROR"]>;
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<["RUNNING", "TERMINAL", "COMPLETED", "STOPPED", "ERROR"]>;
    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<["RUNNING", "TERMINAL", "COMPLETED", "STOPPED", "ERROR"]>;
    descriptor: typeof Schema.Any;
}>, never, {
    readonly id: number;
} & {
    readonly status: "RUNNING" | "TERMINAL" | "COMPLETED" | "STOPPED" | "ERROR";
} & {
    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 {
}
declare const BlockRange_base: Schema.Class<BlockRange, {
    network: typeof Schema.String;
    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: typeof Schema.String;
    numbers: Schema.Struct<{
        start: typeof Schema.Number;
        end: typeof Schema.Number;
    }>;
    hash: typeof Schema.String;
    prevHash: Schema.optional<typeof Schema.String>;
}>, never, {
    readonly hash: string;
} & {
    readonly network: string;
} & {
    readonly numbers: {
        readonly start: number;
        readonly end: number;
    };
} & {
    readonly prevHash?: string | undefined;
}, {}, {}>;
export declare class BlockRange extends BlockRange_base {
}
declare const RecordBatchMetadata_base: Schema.Class<RecordBatchMetadata, {
    ranges: Schema.Array$<typeof BlockRange>;
}, Schema.Struct.Encoded<{
    ranges: Schema.Array$<typeof BlockRange>;
}>, never, {
    readonly ranges: readonly BlockRange[];
}, {}, {}>;
export declare class RecordBatchMetadata extends RecordBatchMetadata_base {
}
declare const DumpResponse_base: Schema.Class<DumpResponse, {
    job_id: Schema.SchemaClass<number, number, never>;
}, Schema.Struct.Encoded<{
    job_id: Schema.SchemaClass<number, number, never>;
}>, never, {
    readonly job_id: number;
}, {}, {}>;
export declare class DumpResponse extends DumpResponse_base {
}
declare const DeployRequest_base: Schema.Class<DeployRequest, {
    endBlock: Schema.PropertySignature<"?:", string | null | undefined, "end_block", "?:", string | null | undefined, false, never>;
    parallelism: Schema.optional<typeof Schema.Number>;
}, Schema.Struct.Encoded<{
    endBlock: Schema.PropertySignature<"?:", string | null | undefined, "end_block", "?:", string | null | undefined, false, never>;
    parallelism: Schema.optional<typeof Schema.Number>;
}>, never, {
    readonly endBlock?: string | null | undefined;
} & {
    readonly parallelism?: number | undefined;
}, {}, {}>;
export declare class DeployRequest extends DeployRequest_base {
}
declare const DeployResponse_base: Schema.Class<DeployResponse, {
    jobId: Schema.PropertySignature<":", number, "job_id", ":", number, false, never>;
}, Schema.Struct.Encoded<{
    jobId: Schema.PropertySignature<":", number, "job_id", ":", number, false, never>;
}>, never, {
    readonly jobId: number;
}, {}, {}>;
export declare class DeployResponse extends DeployResponse_base {
}
export {};
//# sourceMappingURL=Model.d.ts.map