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 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 DependencyValidationError_base: Schema.Class<DependencyValidationError, {
    code: Schema.PropertySignature<":", "DEPENDENCY_VALIDATION_ERROR", "error_code", ":", "DEPENDENCY_VALIDATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}, Schema.Struct.Encoded<{
    code: Schema.PropertySignature<":", "DEPENDENCY_VALIDATION_ERROR", "error_code", ":", "DEPENDENCY_VALIDATION_ERROR", false, never>;
    message: Schema.PropertySignature<":", string, "error_message", ":", string, false, never>;
}>, never, {
    readonly message: string;
} & {
    readonly code: "DEPENDENCY_VALIDATION_ERROR";
}, {}, {}>;
/**
 * DependencyValidationError - Manifest dependency validation error.
 *
 * Causes:
 * - SQL queries are invalid
 * - SQL queries reference datasets not declared in dependencies
 * - Undeclared dependencies in manifest
 * - Circular dependencies
 *
 * Applies to:
 * - POST /datasets - During manifest validation
 */
export declare class DependencyValidationError extends DependencyValidationError_base {
    readonly _tag: "DependencyValidationError";
}
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
 */
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:
 * - Invalid SQL syntax in query
 * - Referenced tables or datasets don't exist
 * - Type mismatches in query
 * - Unsupported SQL features
 * - Schema inference failures
 *
 * Applies to:
 * - Query execution operations
 * - Schema inference 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";
}
export {};
//# sourceMappingURL=Error.d.ts.map