import { Context, Effect, Layer, Schema } from 'effect';
export interface EncodedKey {
    readonly pk: string;
    readonly sk: string;
}
export type JsonValue = string | number | boolean | null | JsonObject | readonly JsonValue[];
export interface JsonObject {
    readonly [key: string]: JsonValue;
}
export type EncodedData = JsonObject & {
    readonly _v: string;
};
export interface EncodedItemMeta {
    readonly _e: string;
    readonly _u: string;
    readonly _d: boolean;
}
export interface EncodedItem extends EncodedKey {
    readonly meta: EncodedItemMeta;
    readonly data: EncodedData;
    readonly keys: Readonly<Record<string, string>>;
}
export declare const EncodedKeySchema: Schema.Codec<EncodedKey>;
export declare const EncodedDataSchema: Schema.declare<EncodedData, EncodedData>;
export declare const EncodedItemSchema: Schema.Codec<EncodedItem>;
export type ItemCondition = {
    readonly kind: 'not-exists';
} | {
    readonly kind: 'exists';
} | {
    readonly kind: 'updated';
    readonly value: string;
};
export interface ConditionalPut {
    readonly item: EncodedItem;
    readonly condition?: ItemCondition;
}
export interface TransactPut extends ConditionalPut {
    readonly kind: 'put';
}
export interface TransactCheck {
    readonly kind: 'check';
    readonly key: EncodedKey;
    readonly condition: ItemCondition;
}
export type TransactItem = TransactPut | TransactCheck;
export declare const transactItemKey: (item: TransactItem) => EncodedKey;
export type ItemOutcomeStatus = 'passed' | 'failed' | 'not-evaluated';
export interface ItemOutcome {
    readonly status: ItemOutcomeStatus;
    readonly detail?: string;
}
export declare const conditionHolds: (condition: ItemCondition | undefined, current: {
    readonly _u: string;
} | undefined) => boolean;
export declare const itemOutcomes: (total: number, failedIndex: number, detail?: string) => readonly ItemOutcome[];
export interface QueryPosition {
    readonly pk: string;
    readonly sk: string;
    readonly indexSk?: string;
}
export interface QueryRequest {
    readonly index?: string;
    readonly pk: string;
    readonly sort?: {
        readonly operator: '=' | '<' | '<=' | '>' | '>=';
        readonly value: string;
    } | {
        readonly operator: 'between';
        readonly value: readonly [string, string];
    } | {
        readonly operator: 'beginsWith';
        readonly value: string;
    };
    readonly descending: boolean;
    readonly limit: number;
    readonly startAfter?: QueryPosition;
}
export interface QueryResult {
    readonly items: readonly EncodedItem[];
    readonly hasMore: boolean;
}
export interface ScanRequest {
    readonly limit: number;
    readonly startAfter?: EncodedKey;
    readonly segment?: number;
    readonly totalSegments?: number;
}
export interface ScanResult {
    readonly items: readonly EncodedItem[];
    readonly hasMore: boolean;
}
declare const ConditionFailure_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: "ConditionFailure";
} & Readonly<A>;
export declare class ConditionFailure extends ConditionFailure_base<{
    readonly outcomes?: readonly ItemOutcome[];
}> {
}
/** A single-item write failing its condition: one condition needs no report. */
export declare const conditionFailed: () => ConditionFailure;
/** A transacted item failing its condition at `index`, with every op's status. */
export declare const checkFailed: (total: number, index: number, condition: ItemCondition | undefined) => ConditionFailure;
declare const OperationFailure_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: "OperationFailure";
} & Readonly<A>;
export declare class OperationFailure extends OperationFailure_base<{
    readonly cause: unknown;
}> {
}
export type ContractFailure = ConditionFailure | OperationFailure;
export interface ReadOptions {
    readonly consistent?: boolean;
}
export interface StdTableContract {
    readonly getItem: (key: EncodedKey, options?: ReadOptions) => Effect.Effect<EncodedItem | null, ContractFailure>;
    readonly queryItems: (request: QueryRequest) => Effect.Effect<QueryResult, ContractFailure>;
    readonly scanItems: (request: ScanRequest) => Effect.Effect<ScanResult, ContractFailure>;
    readonly writeItem: (put: ConditionalPut) => Effect.Effect<void, ContractFailure>;
    readonly transactWriteItems: (items: readonly TransactItem[]) => Effect.Effect<void, ContractFailure>;
    readonly hardDeleteItem: (key: EncodedKey) => Effect.Effect<void, ContractFailure>;
    readonly hardDeleteEntityItems: (entity: string) => Effect.Effect<number, ContractFailure>;
    readonly hardDeleteAllItems: () => Effect.Effect<number, ContractFailure>;
}
declare const stdTableServiceType: unique symbol;
export interface StdTableService<Name extends string> {
    readonly contract: StdTableContract;
    readonly [stdTableServiceType]: Name;
}
export declare const StdTableService: <Name extends string>(logicalName: Name) => Context.Service<StdTableService<Name>, StdTableService<Name>>;
export declare const contractLayer: <Name extends string>(logicalName: Name, contract: StdTableContract) => Layer.Layer<StdTableService<Name>>;
export {};
//# sourceMappingURL=contract.d.ts.map