/**
 * Pg errors
 * @since 1.0.0
 */
import type * as ParseResult from "@effect/schema/ParseResult";
declare const PostgresUnknownError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresUnknownError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresUnknownError extends PostgresUnknownError_base<{
    error: unknown;
}> {
}
declare const PostgresConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresConnectionError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresConnectionError extends PostgresConnectionError_base<{
    error: unknown;
}> {
}
declare const PostgresTableDoesntExistError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresTableDoesntExistError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresTableDoesntExistError extends PostgresTableDoesntExistError_base<{
    error: unknown;
}> {
}
declare const PostgresValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresValidationError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresValidationError extends PostgresValidationError_base<{
    error: ParseResult.ParseError;
}> {
}
declare const PostgresUnexpectedNumberOfRowsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresUnexpectedNumberOfRowsError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresUnexpectedNumberOfRowsError extends PostgresUnexpectedNumberOfRowsError_base<{
    expectedRows: number;
    receivedRows: number;
}> {
}
declare const PostgresDuplicateTableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresDuplicateTableError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresDuplicateTableError extends PostgresDuplicateTableError_base<{
    error: unknown;
}> {
}
declare const PostgresInvalidParametersError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "PostgresInvalidParametersError";
} & Readonly<A>;
/**
 * @category models
 * @since 1.0.0
 */
export declare class PostgresInvalidParametersError extends PostgresInvalidParametersError_base<{
    error: unknown;
}> {
}
/**
 * @category models
 * @since 1.0.0
 */
export type PostgresQueryError = PostgresTableDoesntExistError | PostgresUnknownError | PostgresDuplicateTableError | PostgresInvalidParametersError;
export {};
//# sourceMappingURL=PgError.d.ts.map