declare const ItemAlreadyExists_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ItemAlreadyExists";
} & Readonly<A>;
export declare class ItemAlreadyExists extends ItemAlreadyExists_base<{
    readonly entity: string;
}> {
}
declare const NoItemToUpdate_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "NoItemToUpdate";
} & Readonly<A>;
export declare class NoItemToUpdate extends NoItemToUpdate_base<{
    readonly entity: string;
}> {
}
declare const NoItemToCheck_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "NoItemToCheck";
} & Readonly<A>;
export declare class NoItemToCheck extends NoItemToCheck_base<{
    readonly entity: string;
}> {
}
declare const PrimaryKeyUpdateNotSupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PrimaryKeyUpdateNotSupported";
} & Readonly<A>;
export declare class PrimaryKeyUpdateNotSupported extends PrimaryKeyUpdateNotSupported_base<{
    readonly entity: string;
    readonly fields: readonly string[];
}> {
}
declare const ConditionFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ConditionFailed";
} & Readonly<A>;
export declare class ConditionFailed extends ConditionFailed_base<{
    readonly entity: string;
}> {
}
declare const CheckRefused_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "CheckRefused";
} & Readonly<A>;
export declare class CheckRefused extends CheckRefused_base<{
    readonly entity: string;
}> {
}
declare const InvalidQuery_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "InvalidQuery";
} & Readonly<A>;
export declare class InvalidQuery extends InvalidQuery_base<{
    readonly message: string;
}> {
}
declare const TransactionTooLarge_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "TransactionTooLarge";
} & Readonly<A>;
export declare class TransactionTooLarge extends TransactionTooLarge_base<{
    readonly count: number;
    readonly maximum: 100;
}> {
}
declare const DuplicateTransactionTarget_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "DuplicateTransactionTarget";
} & Readonly<A>;
export declare class DuplicateTransactionTarget extends DuplicateTransactionTarget_base<{
    readonly target: string;
}> {
}
declare const ForeignTransactionItem_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ForeignTransactionItem";
} & Readonly<A>;
export declare class ForeignTransactionItem extends ForeignTransactionItem_base<{
    readonly expectedTable: string;
    readonly actualTable: string;
}> {
}
declare const DecodeFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "DecodeFailed";
} & Readonly<A>;
export declare class DecodeFailed extends DecodeFailed_base<{
    readonly entity: string;
    readonly cause: Error;
}> {
}
export interface TransactOperation {
    readonly tableName: string;
    readonly entityName: string;
    readonly key: {
        readonly pk: string;
        readonly sk: string;
    };
    readonly target: string;
    readonly operationKind: string;
}
export type TransactOutcomeStatus = 'passed' | 'stale' | 'refused' | 'missing' | 'not-evaluated';
export interface TransactOutcome {
    readonly status: TransactOutcomeStatus;
    readonly detail?: string;
    readonly op: TransactOperation;
}
declare const TransactFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "TransactFailed";
} & Readonly<A>;
export declare class TransactFailed extends TransactFailed_base<{
    readonly operations: readonly TransactOutcome[];
}> {
}
declare const OperationFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "OperationFailed";
} & Readonly<A>;
export declare class OperationFailed extends OperationFailed_base<{
    readonly operation: string;
    readonly cause: unknown;
}> {
}
declare const EntityNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "EntityNotFound";
} & Readonly<A>;
export declare class EntityNotFound extends EntityNotFound_base<{
    readonly entity: string;
}> {
}
declare const PrimaryKeyDrift_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PrimaryKeyDrift";
} & Readonly<A>;
export declare class PrimaryKeyDrift extends PrimaryKeyDrift_base<{
    readonly entity: string;
    readonly storedKey: {
        readonly pk: string;
        readonly sk: string;
    };
    readonly currentKey: {
        readonly pk: string;
        readonly sk: string;
    };
}> {
}
declare const ReindexConflict_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ReindexConflict";
} & Readonly<A>;
export declare class ReindexConflict extends ReindexConflict_base<{
    readonly entity: string;
    readonly observedU: string;
}> {
}
export type DatabaseErrorReason = ItemAlreadyExists | NoItemToUpdate | NoItemToCheck | PrimaryKeyUpdateNotSupported | ConditionFailed | CheckRefused | InvalidQuery | TransactionTooLarge | DuplicateTransactionTarget | ForeignTransactionItem | TransactFailed | DecodeFailed | OperationFailed | EntityNotFound | PrimaryKeyDrift | ReindexConflict;
declare const DatabaseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "DatabaseError";
} & Readonly<A>;
export declare class DatabaseError extends DatabaseError_base<{
    readonly reason: DatabaseErrorReason;
}> {
}
export {};
//# sourceMappingURL=error.d.ts.map