import * as Schema from "effect/Schema";
declare const SchedulerError_base: Schema.Class<SchedulerError, {
    code: Schema.PropertySignature<":", "SCHEDULER_ERROR", "error_code", ":", "SCHEDULER_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "SCHEDULER_ERROR", "error_code", ":", "SCHEDULER_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "SCHEDULER_ERROR";
}, {}, {}>;
/**
 * SchedulerError - Indicates a failure in the job scheduling system.
 *
 * Causes:
 * - Failed to schedule a dump job
 * - Worker pool unavailable
 * - Internal scheduler state errors
 *
 * Applies to:
 * - POST /datasets/{name}/dump - When scheduling dataset dumps
 * - POST /datasets - When scheduling registration jobs
 */
export declare class SchedulerError extends SchedulerError_base {
    readonly _tag: "SchedulerError";
}
declare const MetadataDbError_base: Schema.Class<MetadataDbError, {
    code: Schema.PropertySignature<":", "METADATA_DB_ERROR", "error_code", ":", "METADATA_DB_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "METADATA_DB_ERROR", "error_code", ":", "METADATA_DB_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "METADATA_DB_ERROR";
}, {}, {}>;
/**
 * MetadataDbError - Database operation failure in the metadata PostgreSQL database.
 *
 * Causes:
 * - Database connection failures
 * - SQL execution errors
 * - Database migration issues
 * - Worker notification send/receive failures
 * - Data consistency errors (e.g., multiple active locations)
 *
 * Applies to:
 * - Any operation that queries or updates metadata
 * - Worker coordination operations
 * - Dataset state tracking
 */
export declare class MetadataDbError extends MetadataDbError_base {
    readonly _tag: "MetadataDbError";
}
declare const DatasetStoreError_base: Schema.Class<DatasetStoreError, {
    code: Schema.PropertySignature<":", "DATASET_STORE_ERROR", "error_code", ":", "DATASET_STORE_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "DATASET_STORE_ERROR", "error_code", ":", "DATASET_STORE_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "DATASET_STORE_ERROR";
}, {}, {}>;
/**
 * DatasetStoreError - Failure in dataset storage operations.
 *
 * Causes:
 * - File/object store retrieval failures
 * - Manifest parsing errors (TOML/JSON)
 * - Unsupported dataset kind
 * - Dataset name validation failures
 * - Schema validation errors (missing or mismatched)
 * - Provider configuration not found
 * - SQL parsing failures in dataset definitions
 *
 * Applies to:
 * - GET /datasets - Listing datasets
 * - GET /datasets/{id} - Retrieving specific dataset
 * - POST /datasets/{id}/dump - When loading dataset definitions
 * - Query operations that access dataset metadata
 */
export declare class DatasetStoreError extends DatasetStoreError_base {
    readonly _tag: "DatasetStoreError";
}
declare const DatasetNotFound_base: Schema.Class<DatasetNotFound, {
    code: Schema.PropertySignature<":", "DATASET_NOT_FOUND", "error_code", ":", "DATASET_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "DATASET_NOT_FOUND", "error_code", ":", "DATASET_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "DATASET_NOT_FOUND";
}, {}, {}>;
/**
 * DatasetNotFound - The requested dataset does not exist.
 *
 * Causes:
 * - Dataset ID does not exist in the system
 * - Dataset has been deleted
 * - Dataset not yet registered
 *
 * Applies to:
 * - GET /datasets/{id} - When dataset ID doesn't exist
 * - POST /datasets/{id}/dump - When attempting to dump non-existent dataset
 * - Query operations referencing non-existent datasets
 */
export declare class DatasetNotFound extends DatasetNotFound_base {
    readonly _tag: "DatasetNotFound";
}
declare const TableNotFoundInDataset_base: Schema.Class<TableNotFoundInDataset, {
    code: Schema.PropertySignature<":", "TABLE_NOT_FOUND_IN_DATASET", "error_code", ":", "TABLE_NOT_FOUND_IN_DATASET", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "TABLE_NOT_FOUND_IN_DATASET", "error_code", ":", "TABLE_NOT_FOUND_IN_DATASET", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "TABLE_NOT_FOUND_IN_DATASET";
}, {}, {}>;
/**
 * TableNotFoundInDataset - Table not found in dataset.
 *
 * Causes:
 * - Table name referenced in SQL query does not exist in the dataset
 * - Table name is misspelled
 * - Dataset does not contain the referenced table
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries with invalid table references
 */
export declare class TableNotFoundInDataset extends TableNotFoundInDataset_base {
    readonly _tag: "TableNotFoundInDataset";
}
declare const InvalidSelector_base: Schema.Class<InvalidSelector, {
    code: Schema.PropertySignature<":", "INVALID_SELECTOR", "error_code", ":", "INVALID_SELECTOR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_SELECTOR", "error_code", ":", "INVALID_SELECTOR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_SELECTOR";
}, {}, {}>;
/**
 * InvalidSelector - The provided dataset selector (name/version) is malformed or invalid.
 *
 * Causes:
 * - Dataset name contains invalid characters or doesn't follow naming conventions
 * - Dataset name is empty or malformed
 * - Version syntax is invalid (e.g., malformed semver)
 * - Path parameter extraction fails for dataset selection
 *
 * Applies to:
 * - GET /datasets/{name} - When dataset name format is invalid
 * - GET /datasets/{name}/versions/{version} - When name or version format is invalid
 * - Any endpoint accepting dataset selector parameters
 */
export declare class InvalidSelector extends InvalidSelector_base {
    readonly _tag: "InvalidSelector";
}
declare const InvalidRequest_base: Schema.Class<InvalidRequest, {
    code: Schema.PropertySignature<":", "INVALID_REQUEST", "error_code", ":", "INVALID_REQUEST", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_REQUEST", "error_code", ":", "INVALID_REQUEST", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_REQUEST";
}, {}, {}>;
/**
 * InvalidRequest - The request is malformed or contains invalid parameters.
 *
 * Causes:
 * - Missing required request parameters
 * - Invalid parameter values
 * - Malformed request body
 * - Invalid content type
 * - Request validation failures
 *
 * Applies to:
 * - POST /datasets - Invalid registration request
 * - POST /datasets/{id}/dump - Invalid dump parameters
 * - Any endpoint with request validation
 */
export declare class InvalidRequest extends InvalidRequest_base {
    readonly _tag: "InvalidRequest";
}
declare const InvalidManifest_base: Schema.Class<InvalidManifest, {
    code: Schema.PropertySignature<":", "INVALID_MANIFEST", "error_code", ":", "INVALID_MANIFEST", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_MANIFEST", "error_code", ":", "INVALID_MANIFEST", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_MANIFEST";
}, {}, {}>;
/**
 * InvalidManifest - Dataset manifest is semantically invalid.
 *
 * Causes:
 * - Invalid dataset references in SQL views
 * - Circular dependencies between datasets
 * - Invalid provider references
 * - Schema validation failures
 * - Invalid dataset configuration
 *
 * Applies to:
 * - POST /datasets - During manifest validation
 * - Dataset initialization
 * - Different from ManifestParseError (syntax vs semantics)
 */
export declare class InvalidManifest extends InvalidManifest_base {
    readonly _tag: "InvalidManifest";
}
declare const UnexpectedJobStatus_base: Schema.Class<UnexpectedJobStatus, {
    code: Schema.PropertySignature<":", "UNEXPECTED_JOB_STATUS", "error_code", ":", "UNEXPECTED_JOB_STATUS", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "UNEXPECTED_JOB_STATUS", "error_code", ":", "UNEXPECTED_JOB_STATUS", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "UNEXPECTED_JOB_STATUS";
}, {}, {}>;
/**
 * UnexpectedJobStatus - Job is in an unexpected state for the requested operation.
 *
 * Causes:
 * - Attempting to schedule a dump when one is already running
 * - Job state machine violations
 * - Concurrent job modification attempts
 * - Invalid state transitions
 *
 * Applies to:
 * - POST /datasets/{id}/dump - When a dump is already in progress
 * - Job management operations
 *
 * Example: Trying to start a dump job when status is already "Running"
 */
export declare class UnexpectedJobStatus extends UnexpectedJobStatus_base {
    readonly _tag: "UnexpectedJobStatus";
}
declare const JobNotFound_base: Schema.Class<JobNotFound, {
    code: Schema.PropertySignature<":", "JOB_NOT_FOUND", "error_code", ":", "JOB_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "JOB_NOT_FOUND", "error_code", ":", "JOB_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "JOB_NOT_FOUND";
}, {}, {}>;
/**
 * JobNotFound - The requested job does not exist.
 *
 * Causes:
 * - Job ID does not exist in the system
 * - Job has been deleted
 * - Job has completed and been cleaned up
 *
 * Applies to:
 * - GET /jobs/{id} - When job ID doesn't exist
 * - DELETE /jobs/{id} - When attempting to delete non-existent job
 * - PUT /jobs/{id}/stop - When attempting to stop non-existent job
 */
export declare class JobNotFound extends JobNotFound_base {
    readonly _tag: "JobNotFound";
}
declare const InvalidQueryParameters_base: Schema.Class<InvalidQueryParameters, {
    code: Schema.PropertySignature<":", "INVALID_QUERY_PARAMETERS", "error_code", ":", "INVALID_QUERY_PARAMETERS", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_QUERY_PARAMETERS", "error_code", ":", "INVALID_QUERY_PARAMETERS", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_QUERY_PARAMETERS";
}, {}, {}>;
/**
 * InvalidQueryParameters - The query parameters are invalid or malformed.
 *
 * Causes:
 * - Invalid integer format for limit or pagination cursors
 * - Malformed query string syntax
 * - Missing required query parameters
 * - Query parameter validation failures
 *
 * Applies to:
 * - GET /jobs - Invalid pagination parameters
 * - Any endpoint with query parameter validation
 */
export declare class InvalidQueryParameters extends InvalidQueryParameters_base {
    readonly _tag: "InvalidQueryParameters";
}
declare const LimitTooLarge_base: Schema.Class<LimitTooLarge, {
    code: Schema.PropertySignature<":", "LIMIT_TOO_LARGE", "error_code", ":", "LIMIT_TOO_LARGE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "LIMIT_TOO_LARGE", "error_code", ":", "LIMIT_TOO_LARGE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "LIMIT_TOO_LARGE";
}, {}, {}>;
/**
 * LimitTooLarge - The requested limit exceeds the maximum allowed value.
 *
 * Causes:
 * - Limit parameter greater than maximum page size (1000)
 * - Attempting to request too many records at once
 * - Pagination limit validation failure
 *
 * Applies to:
 * - GET /jobs - When limit exceeds maximum
 * - Any paginated endpoint with limit validation
 */
export declare class LimitTooLarge extends LimitTooLarge_base {
    readonly _tag: "LimitTooLarge";
}
declare const LimitInvalid_base: Schema.Class<LimitInvalid, {
    code: Schema.PropertySignature<":", "LIMIT_INVALID", "error_code", ":", "LIMIT_INVALID", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "LIMIT_INVALID", "error_code", ":", "LIMIT_INVALID", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "LIMIT_INVALID";
}, {}, {}>;
/**
 * LimitInvalid - The requested limit is invalid (zero or negative).
 *
 * Causes:
 * - Limit parameter is 0 or negative
 * - Invalid limit format or type
 * - Limit validation failure
 *
 * Applies to:
 * - GET /jobs - When limit is 0 or negative
 * - Any paginated endpoint with limit validation
 */
export declare class LimitInvalid extends LimitInvalid_base {
    readonly _tag: "LimitInvalid";
}
declare const ManifestRegistrationError_base: Schema.Class<ManifestRegistrationError, {
    code: Schema.PropertySignature<":", "MANIFEST_REGISTRATION_ERROR", "error_code", ":", "MANIFEST_REGISTRATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "MANIFEST_REGISTRATION_ERROR", "error_code", ":", "MANIFEST_REGISTRATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "MANIFEST_REGISTRATION_ERROR";
}, {}, {}>;
/**
 * ManifestRegistrationError - Failed to register manifest in the system.
 *
 * Causes:
 * - Internal error during manifest registration
 * - Registry service unavailable
 * - Manifest storage failure
 *
 * Applies to:
 * - POST /datasets - During manifest registration
 * - POST /datasets - During manifest registration
 */
export declare class ManifestRegistrationError extends ManifestRegistrationError_base {
    readonly _tag: "ManifestRegistrationError";
}
declare const ManifestLinkingError_base: Schema.Class<ManifestLinkingError, {
    code: Schema.PropertySignature<":", "MANIFEST_LINKING_ERROR", "error_code", ":", "MANIFEST_LINKING_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "MANIFEST_LINKING_ERROR", "error_code", ":", "MANIFEST_LINKING_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "MANIFEST_LINKING_ERROR";
}, {}, {}>;
/**
 * ManifestLinkingError - Failed to link manifest to dataset.
 *
 * Causes:
 * - Error during manifest linking in metadata database
 * - Error updating dev tag
 * - Database transaction failure
 * - Foreign key constraint violations
 *
 * Applies to:
 * - POST /datasets - During manifest linking to dataset
 */
export declare class ManifestLinkingError extends ManifestLinkingError_base {
    readonly _tag: "ManifestLinkingError";
}
declare const VersionTaggingError_base: Schema.Class<VersionTaggingError, {
    code: Schema.PropertySignature<":", "VERSION_TAGGING_ERROR", "error_code", ":", "VERSION_TAGGING_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "VERSION_TAGGING_ERROR", "error_code", ":", "VERSION_TAGGING_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "VERSION_TAGGING_ERROR";
}, {}, {}>;
/**
 * VersionTaggingError - Failed to tag version for the dataset.
 *
 * Causes:
 * - Error during version tagging in metadata database
 * - Invalid semantic version format
 * - Error updating latest tag
 * - Database constraint violations
 *
 * Applies to:
 * - POST /datasets - During version tagging
 */
export declare class VersionTaggingError extends VersionTaggingError_base {
    readonly _tag: "VersionTaggingError";
}
declare const ManifestValidationError_base: Schema.Class<ManifestValidationError, {
    code: Schema.PropertySignature<":", "MANIFEST_VALIDATION_ERROR", "error_code", ":", "MANIFEST_VALIDATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "MANIFEST_VALIDATION_ERROR", "error_code", ":", "MANIFEST_VALIDATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "MANIFEST_VALIDATION_ERROR";
}, {}, {}>;
/**
 * ManifestValidationError - Manifest validation error.
 *
 * Causes:
 * - SQL queries contain non-incremental operations
 * - Invalid table references in SQL
 * - Schema validation failures
 * - Type inference errors
 *
 * Applies to:
 * - POST /datasets - During manifest validation
 */
export declare class ManifestValidationError extends ManifestValidationError_base {
    readonly _tag: "ManifestValidationError";
}
declare const UnsupportedDatasetKind_base: Schema.Class<UnsupportedDatasetKind, {
    code: Schema.PropertySignature<":", "UNSUPPORTED_DATASET_KIND", "error_code", ":", "UNSUPPORTED_DATASET_KIND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "UNSUPPORTED_DATASET_KIND", "error_code", ":", "UNSUPPORTED_DATASET_KIND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "UNSUPPORTED_DATASET_KIND";
}, {}, {}>;
/**
 * UnsupportedDatasetKind - Dataset kind is not supported.
 *
 * Causes:
 * - Dataset kind is not one of the supported types (manifest, evm-rpc, firehose, eth-beacon)
 * - Invalid or unknown dataset kind value
 * - Legacy dataset kinds that are no longer supported
 *
 * Applies to:
 * - POST /datasets - During manifest validation
 */
export declare class UnsupportedDatasetKind extends UnsupportedDatasetKind_base {
    readonly _tag: "UnsupportedDatasetKind";
}
declare const ManifestNotFound_base: Schema.Class<ManifestNotFound, {
    code: Schema.PropertySignature<":", "MANIFEST_NOT_FOUND", "error_code", ":", "MANIFEST_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "MANIFEST_NOT_FOUND", "error_code", ":", "MANIFEST_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "MANIFEST_NOT_FOUND";
}, {}, {}>;
/**
 * ManifestNotFound - Manifest with the provided hash not found.
 *
 * Causes:
 * - A manifest hash was provided but the manifest doesn't exist in the system
 * - The hash is valid format but no manifest is stored with that hash
 * - Manifest was deleted or never registered
 *
 * Applies to:
 * - POST /datasets - When linking to a manifest hash that doesn't exist
 */
export declare class ManifestNotFound extends ManifestNotFound_base {
    readonly _tag: "ManifestNotFound";
}
declare const InvalidPayloadFormat_base: Schema.Class<InvalidPayloadFormat, {
    code: Schema.PropertySignature<":", "INVALID_PAYLOAD_FORMAT", "error_code", ":", "INVALID_PAYLOAD_FORMAT", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_PAYLOAD_FORMAT", "error_code", ":", "INVALID_PAYLOAD_FORMAT", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_PAYLOAD_FORMAT";
}, {}, {}>;
/**
 * InvalidPayloadFormat - Invalid request payload format.
 *
 * Causes:
 * - Request JSON is malformed or invalid
 * - Required fields are missing or have wrong types
 * - Dataset name or version format is invalid
 * - JSON deserialization failures
 *
 * Applies to:
 * - POST /datasets - When request body is invalid
 * - POST /schema - When request payload cannot be parsed
 */
export declare class InvalidPayloadFormat extends InvalidPayloadFormat_base {
    readonly _tag: "InvalidPayloadFormat";
}
declare const StoreError_base: Schema.Class<StoreError, {
    code: Schema.PropertySignature<":", "STORE_ERROR", "error_code", ":", "STORE_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "STORE_ERROR", "error_code", ":", "STORE_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "STORE_ERROR";
}, {}, {}>;
/**
 * StoreError - Dataset store operation error.
 *
 * Causes:
 * - Failed to load dataset from store
 * - Dataset store configuration errors
 * - Dataset store connectivity issues
 * - Object store access failures
 *
 * Applies to:
 * - POST /datasets - During dataset store operations
 */
export declare class StoreError extends StoreError_base {
    readonly _tag: "StoreError";
}
declare const InvalidJobId_base: Schema.Class<InvalidJobId, {
    code: Schema.PropertySignature<":", "INVALID_JOB_ID", "error_code", ":", "INVALID_JOB_ID", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_JOB_ID", "error_code", ":", "INVALID_JOB_ID", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_JOB_ID";
}, {}, {}>;
/**
 * InvalidJobId - The provided job ID is malformed or invalid.
 *
 * Causes:
 * - Job ID contains invalid characters
 * - Job ID format does not match expected pattern
 * - Empty or null job ID
 * - Job ID is not a valid integer
 *
 * Applies to:
 * - GET /jobs/{id} - When ID format is invalid
 * - DELETE /jobs/{id} - When ID format is invalid
 * - PUT /jobs/{id}/stop - When ID format is invalid
 */
export declare class InvalidJobId extends InvalidJobId_base {
    readonly _tag: "InvalidJobId";
}
declare const RegistrationFailed_base: Schema.Class<RegistrationFailed, {
    code: Schema.PropertySignature<":", "REGISTRATION_FAILED", "error_code", ":", "REGISTRATION_FAILED", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "REGISTRATION_FAILED", "error_code", ":", "REGISTRATION_FAILED", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "REGISTRATION_FAILED";
}, {}, {}>;
/**
 * RegistrationFailed - Failed to register manifest in the registry system.
 *
 * Causes:
 * - Dataset already exists with the given name and version
 * - Dataset store error during manifest storage
 * - Database error during registry operations
 * - Serialization error when processing manifest
 *
 * Applies to:
 * - POST /register - When manifest registration fails
 */
export declare class RegistrationFailed extends RegistrationFailed_base {
    readonly _tag: "RegistrationFailed";
}
declare const PlanningError_base: Schema.Class<PlanningError, {
    code: Schema.PropertySignature<":", "PLANNING_ERROR", "error_code", ":", "PLANNING_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "PLANNING_ERROR", "error_code", ":", "PLANNING_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "PLANNING_ERROR";
}, {}, {}>;
/**
 * PlanningError - Query planning failure.
 *
 * Causes:
 * - Query planning fails due to invalid references
 * - Type inference failures
 * - Schema determination errors
 * - Internal DataFusion planning errors
 *
 * Applies to:
 * - POST /schema - When determining output schema
 * - Query execution operations
 */
export declare class PlanningError extends PlanningError_base {
    readonly _tag: "PlanningError";
}
declare const CatalogForSqlError_base: Schema.Class<CatalogForSqlError, {
    code: Schema.PropertySignature<":", "CATALOG_FOR_SQL_ERROR", "error_code", ":", "CATALOG_FOR_SQL_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "CATALOG_FOR_SQL_ERROR", "error_code", ":", "CATALOG_FOR_SQL_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "CATALOG_FOR_SQL_ERROR";
}, {}, {}>;
/**
 * CatalogForSqlError - Failure to build catalog for SQL query.
 *
 * Causes:
 * - Failed to load datasets referenced in SQL query
 * - Dataset store unavailable for catalog construction
 * - Invalid dataset references in query
 * - Catalog initialization failures
 *
 * Applies to:
 * - Query execution operations
 * - Schema inference operations (POST /schema)
 */
export declare class CatalogForSqlError extends CatalogForSqlError_base {
    readonly _tag: "CatalogForSqlError";
}
declare const UnqualifiedTable_base: Schema.Class<UnqualifiedTable, {
    code: Schema.PropertySignature<":", "UNQUALIFIED_TABLE", "error_code", ":", "UNQUALIFIED_TABLE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "UNQUALIFIED_TABLE", "error_code", ":", "UNQUALIFIED_TABLE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "UNQUALIFIED_TABLE";
}, {}, {}>;
/**
 * UnqualifiedTable - Table reference is not qualified with a dataset.
 *
 * Causes:
 * - SQL query contains a table reference without a schema/dataset qualifier
 * - All tables must be qualified with a dataset reference (e.g., dataset.table)
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries
 * - Query operations with unqualified table references
 */
export declare class UnqualifiedTable extends UnqualifiedTable_base {
    readonly _tag: "UnqualifiedTable";
}
declare const CatalogQualifiedTable_base: Schema.Class<CatalogQualifiedTable, {
    code: Schema.PropertySignature<":", "CATALOG_QUALIFIED_TABLE", "error_code", ":", "CATALOG_QUALIFIED_TABLE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "CATALOG_QUALIFIED_TABLE", "error_code", ":", "CATALOG_QUALIFIED_TABLE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "CATALOG_QUALIFIED_TABLE";
}, {}, {}>;
/**
 * CatalogQualifiedTable - Table reference includes a catalog qualifier.
 *
 * Causes:
 * - SQL query contains a catalog-qualified table reference (catalog.schema.table)
 * - Only dataset-qualified tables are supported (dataset.table)
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries
 * - Query operations with catalog-qualified table references
 */
export declare class CatalogQualifiedTable extends CatalogQualifiedTable_base {
    readonly _tag: "CatalogQualifiedTable";
}
declare const InvalidTableName_base: Schema.Class<InvalidTableName, {
    code: Schema.PropertySignature<":", "INVALID_TABLE_NAME", "error_code", ":", "INVALID_TABLE_NAME", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_TABLE_NAME", "error_code", ":", "INVALID_TABLE_NAME", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_TABLE_NAME";
}, {}, {}>;
/**
 * InvalidTableName - Table name does not conform to SQL identifier rules.
 *
 * Causes:
 * - Table name contains invalid characters
 * - Table name doesn't follow naming conventions
 * - Table name exceeds maximum length
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries
 * - Query operations with invalid table names
 */
export declare class InvalidTableName extends InvalidTableName_base {
    readonly _tag: "InvalidTableName";
}
declare const InvalidSchemaReference_base: Schema.Class<InvalidSchemaReference, {
    code: Schema.PropertySignature<":", "INVALID_SCHEMA_REFERENCE", "error_code", ":", "INVALID_SCHEMA_REFERENCE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_SCHEMA_REFERENCE", "error_code", ":", "INVALID_SCHEMA_REFERENCE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_SCHEMA_REFERENCE";
}, {}, {}>;
/**
 * InvalidSchemaReference - Schema portion of table reference is not a valid dataset reference.
 *
 * Causes:
 * - Schema/dataset reference format is invalid
 * - Dataset reference doesn't conform to expected format (namespace/name@version)
 * - Invalid characters or structure in dataset reference
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries
 * - Query operations with invalid schema references
 */
export declare class InvalidSchemaReference extends InvalidSchemaReference_base {
    readonly _tag: "InvalidSchemaReference";
}
declare const ResolveHashError_base: Schema.Class<ResolveHashError, {
    code: Schema.PropertySignature<":", "RESOLVE_HASH_ERROR", "error_code", ":", "RESOLVE_HASH_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "RESOLVE_HASH_ERROR", "error_code", ":", "RESOLVE_HASH_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "RESOLVE_HASH_ERROR";
}, {}, {}>;
/**
 * ResolveHashError - Failed to resolve dataset reference to hash.
 *
 * Causes:
 * - Dataset store cannot resolve a reference to content hash
 * - Storage backend errors
 * - Invalid reference format
 *
 * Applies to:
 * - POST /schema - When resolving dataset references
 */
export declare class ResolveHashError extends ResolveHashError_base {
    readonly _tag: "ResolveHashError";
}
declare const GetDatasetError_base: Schema.Class<GetDatasetError, {
    code: Schema.PropertySignature<":", "GET_DATASET_ERROR", "error_code", ":", "GET_DATASET_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "GET_DATASET_ERROR", "error_code", ":", "GET_DATASET_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "GET_DATASET_ERROR";
}, {}, {}>;
/**
 * GetDatasetError - Failed to retrieve dataset from store.
 *
 * Causes:
 * - Dataset manifest is invalid or corrupted
 * - Unsupported dataset kind
 * - Storage backend errors when reading dataset
 *
 * Applies to:
 * - POST /schema - When loading dataset definitions
 */
export declare class GetDatasetError extends GetDatasetError_base {
    readonly _tag: "GetDatasetError";
}
declare const EthCallUdfCreationError_base: Schema.Class<EthCallUdfCreationError, {
    code: Schema.PropertySignature<":", "ETH_CALL_UDF_CREATION_ERROR", "error_code", ":", "ETH_CALL_UDF_CREATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "ETH_CALL_UDF_CREATION_ERROR", "error_code", ":", "ETH_CALL_UDF_CREATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "ETH_CALL_UDF_CREATION_ERROR";
}, {}, {}>;
/**
 * EthCallUdfCreationError - Failed to create ETH call UDF.
 *
 * Causes:
 * - Invalid provider configuration for dataset
 * - Provider connection issues
 * - Dataset is not an EVM RPC dataset but eth_call was requested
 *
 * Applies to:
 * - POST /schema - When creating ETH call UDFs
 */
export declare class EthCallUdfCreationError extends EthCallUdfCreationError_base {
    readonly _tag: "EthCallUdfCreationError";
}
declare const InvalidFunctionReference_base: Schema.Class<InvalidFunctionReference, {
    code: Schema.PropertySignature<":", "INVALID_FUNCTION_REFERENCE", "error_code", ":", "INVALID_FUNCTION_REFERENCE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_FUNCTION_REFERENCE", "error_code", ":", "INVALID_FUNCTION_REFERENCE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_FUNCTION_REFERENCE";
}, {}, {}>;
/**
 * InvalidFunctionReference - Invalid function reference in SQL.
 *
 * Causes:
 * - Function's dataset qualifier cannot be parsed as valid dataset reference
 * - Invalid function qualification format
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries with dataset-qualified functions
 */
export declare class InvalidFunctionReference extends InvalidFunctionReference_base {
    readonly _tag: "InvalidFunctionReference";
}
declare const InvalidFunctionFormat_base: Schema.Class<InvalidFunctionFormat, {
    code: Schema.PropertySignature<":", "INVALID_FUNCTION_FORMAT", "error_code", ":", "INVALID_FUNCTION_FORMAT", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_FUNCTION_FORMAT", "error_code", ":", "INVALID_FUNCTION_FORMAT", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_FUNCTION_FORMAT";
}, {}, {}>;
/**
 * InvalidFunctionFormat - Invalid function format in SQL.
 *
 * Causes:
 * - Function names must be either unqualified or dataset-qualified
 * - Function has more than two parts
 * - Invalid function naming format
 *
 * Applies to:
 * - POST /schema - When analyzing SQL queries with functions
 */
export declare class InvalidFunctionFormat extends InvalidFunctionFormat_base {
    readonly _tag: "InvalidFunctionFormat";
}
declare const SqlParseError_base: Schema.Class<SqlParseError, {
    code: Schema.PropertySignature<":", "SQL_PARSE_ERROR", "error_code", ":", "SQL_PARSE_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "SQL_PARSE_ERROR", "error_code", ":", "SQL_PARSE_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "SQL_PARSE_ERROR";
}, {}, {}>;
/**
 * SqlParseError - SQL parse error.
 *
 * Causes:
 * - SQL query has invalid syntax
 * - Unsupported SQL features are used
 * - Query parsing fails
 *
 * Applies to:
 * - POST /schema - When parsing SQL queries
 */
export declare class SqlParseError extends SqlParseError_base {
    readonly _tag: "SqlParseError";
}
declare const FunctionNotFoundInDataset_base: Schema.Class<FunctionNotFoundInDataset, {
    code: Schema.PropertySignature<":", "FUNCTION_NOT_FOUND_IN_DATASET", "error_code", ":", "FUNCTION_NOT_FOUND_IN_DATASET", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "FUNCTION_NOT_FOUND_IN_DATASET", "error_code", ":", "FUNCTION_NOT_FOUND_IN_DATASET", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "FUNCTION_NOT_FOUND_IN_DATASET";
}, {}, {}>;
/**
 * FunctionNotFoundInDataset - Function not found in referenced dataset.
 *
 * Causes:
 * - SQL query references a function that doesn't exist in the dataset
 * - Function name is misspelled or dataset doesn't define the function
 *
 * Applies to:
 * - POST /schema - When resolving function references
 */
export declare class FunctionNotFoundInDataset extends FunctionNotFoundInDataset_base {
    readonly _tag: "FunctionNotFoundInDataset";
}
declare const EthCallNotAvailable_base: Schema.Class<EthCallNotAvailable, {
    code: Schema.PropertySignature<":", "ETH_CALL_NOT_AVAILABLE", "error_code", ":", "ETH_CALL_NOT_AVAILABLE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "ETH_CALL_NOT_AVAILABLE", "error_code", ":", "ETH_CALL_NOT_AVAILABLE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "ETH_CALL_NOT_AVAILABLE";
}, {}, {}>;
/**
 * EthCallNotAvailable - eth_call function not available for dataset.
 *
 * Causes:
 * - eth_call function is referenced in SQL but dataset doesn't support it
 * - Dataset is not an EVM RPC dataset
 *
 * Applies to:
 * - POST /schema - When checking eth_call availability
 */
export declare class EthCallNotAvailable extends EthCallNotAvailable_base {
    readonly _tag: "EthCallNotAvailable";
}
declare const DependencyNotFound_base: Schema.Class<DependencyNotFound, {
    code: Schema.PropertySignature<":", "DEPENDENCY_NOT_FOUND", "error_code", ":", "DEPENDENCY_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "DEPENDENCY_NOT_FOUND", "error_code", ":", "DEPENDENCY_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "DEPENDENCY_NOT_FOUND";
}, {}, {}>;
/**
 * DependencyNotFound - Dependency not found in dataset store.
 *
 * Causes:
 * - Referenced dependency does not exist in dataset store
 * - Specified version or hash cannot be found
 *
 * Applies to:
 * - POST /schema - When resolving dependencies
 */
export declare class DependencyNotFound extends DependencyNotFound_base {
    readonly _tag: "DependencyNotFound";
}
declare const DependencyAliasNotFound_base: Schema.Class<DependencyAliasNotFound, {
    code: Schema.PropertySignature<":", "DEPENDENCY_ALIAS_NOT_FOUND", "error_code", ":", "DEPENDENCY_ALIAS_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "DEPENDENCY_ALIAS_NOT_FOUND", "error_code", ":", "DEPENDENCY_ALIAS_NOT_FOUND", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "DEPENDENCY_ALIAS_NOT_FOUND";
}, {}, {}>;
/**
 * DependencyAliasNotFound - Dependency alias not found in dependencies map.
 *
 * Causes:
 * - Table reference uses an alias not provided in dependencies
 * - Function reference uses an alias not provided in dependencies
 *
 * Applies to:
 * - POST /schema - When looking up dependency aliases
 */
export declare class DependencyAliasNotFound extends DependencyAliasNotFound_base {
    readonly _tag: "DependencyAliasNotFound";
}
declare const EmptyTablesAndFunctions_base: Schema.Class<EmptyTablesAndFunctions, {
    code: Schema.PropertySignature<":", "EMPTY_TABLES_AND_FUNCTIONS", "error_code", ":", "EMPTY_TABLES_AND_FUNCTIONS", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "EMPTY_TABLES_AND_FUNCTIONS", "error_code", ":", "EMPTY_TABLES_AND_FUNCTIONS", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "EMPTY_TABLES_AND_FUNCTIONS";
}, {}, {}>;
/**
 * EmptyTablesAndFunctions - No tables or functions provided.
 *
 * Causes:
 * - At least one table or function is required for schema analysis
 *
 * Applies to:
 * - POST /schema - When both tables and functions fields are empty
 */
export declare class EmptyTablesAndFunctions extends EmptyTablesAndFunctions_base {
    readonly _tag: "EmptyTablesAndFunctions";
}
declare const InvalidTableSql_base: Schema.Class<InvalidTableSql, {
    code: Schema.PropertySignature<":", "INVALID_TABLE_SQL", "error_code", ":", "INVALID_TABLE_SQL", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "INVALID_TABLE_SQL", "error_code", ":", "INVALID_TABLE_SQL", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "INVALID_TABLE_SQL";
}, {}, {}>;
/**
 * InvalidTableSql - SQL syntax error in table definition.
 *
 * Causes:
 * - Query parsing fails
 *
 * Applies to:
 * - POST /schema - When analyzing table SQL queries
 */
export declare class InvalidTableSql extends InvalidTableSql_base {
    readonly _tag: "InvalidTableSql";
}
declare const TableReferenceResolution_base: Schema.Class<TableReferenceResolution, {
    code: Schema.PropertySignature<":", "TABLE_REFERENCE_RESOLUTION", "error_code", ":", "TABLE_REFERENCE_RESOLUTION", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "TABLE_REFERENCE_RESOLUTION", "error_code", ":", "TABLE_REFERENCE_RESOLUTION", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "TABLE_REFERENCE_RESOLUTION";
}, {}, {}>;
/**
 * TableReferenceResolution - Failed to extract table references from SQL.
 *
 * Causes:
 * - Invalid table reference format encountered
 *
 * Applies to:
 * - POST /schema - When resolving table references
 */
export declare class TableReferenceResolution extends TableReferenceResolution_base {
    readonly _tag: "TableReferenceResolution";
}
declare const FunctionReferenceResolution_base: Schema.Class<FunctionReferenceResolution, {
    code: Schema.PropertySignature<":", "FUNCTION_REFERENCE_RESOLUTION", "error_code", ":", "FUNCTION_REFERENCE_RESOLUTION", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "FUNCTION_REFERENCE_RESOLUTION", "error_code", ":", "FUNCTION_REFERENCE_RESOLUTION", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "FUNCTION_REFERENCE_RESOLUTION";
}, {}, {}>;
/**
 * FunctionReferenceResolution - Failed to resolve function references from SQL.
 *
 * Causes:
 * - Unsupported DML statements encountered
 *
 * Applies to:
 * - POST /schema - When resolving function references
 */
export declare class FunctionReferenceResolution extends FunctionReferenceResolution_base {
    readonly _tag: "FunctionReferenceResolution";
}
declare const DependencyResolution_base: Schema.Class<DependencyResolution, {
    code: Schema.PropertySignature<":", "DEPENDENCY_RESOLUTION", "error_code", ":", "DEPENDENCY_RESOLUTION", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "DEPENDENCY_RESOLUTION", "error_code", ":", "DEPENDENCY_RESOLUTION", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "DEPENDENCY_RESOLUTION";
}, {}, {}>;
/**
 * DependencyResolution - Failed to resolve dependency.
 *
 * Causes:
 * - Database query fails during resolution
 *
 * Applies to:
 * - POST /schema - When resolving dependencies
 */
export declare class DependencyResolution extends DependencyResolution_base {
    readonly _tag: "DependencyResolution";
}
declare const SchemaInference_base: Schema.Class<SchemaInference, {
    code: Schema.PropertySignature<":", "SCHEMA_INFERENCE", "error_code", ":", "SCHEMA_INFERENCE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "SCHEMA_INFERENCE", "error_code", ":", "SCHEMA_INFERENCE", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "SCHEMA_INFERENCE";
}, {}, {}>;
/**
 * SchemaInference - Failed to infer output schema from query.
 *
 * Causes:
 * - Schema determination encounters errors
 *
 * Applies to:
 * - POST /schema - When inferring output schema
 */
export declare class SchemaInference extends SchemaInference_base {
    readonly _tag: "SchemaInference";
}
export {};
//# sourceMappingURL=Error.d.ts.map