/**
 * Low-level Effect wrappers for Storage, including session + localStorage, and its usage via Context.
 * @since 8.19.0
 */
import type { ParseOptions } from "@effect/schema/AST";
import * as ParseResult from "@effect/schema/ParseResult";
import * as S from "@effect/schema/Schema";
import * as Context from "@typed/context";
import * as Effect from "effect/Effect";
import type * as Layer from "effect/Layer";
import * as O from "effect/Option";
import { Window } from "./Window.js";
/**
 * The (local/session)Storage interface is a simple key/value store, used to store data
 * persistently across browser sessions.
 * @since 8.19.0
 * @category models
 */
export interface Storage extends globalThis.Storage {
}
/**
 * The (local/session)Storage interface is a simple key/value store, used to store data
 * persistently across browser sessions.
 * @since 8.19.0
 * @category context
 */
export declare const Storage: Context.Tagged<Storage>;
/**
 * Get an item from storage
 * @since 8.19.0
 * @category getters
 */
export declare const getItem: (key: string) => StorageEffect<O.Option<string>>;
/**
 * set an item from storage
 * @since 8.19.0
 * @category setters
 */
export declare const setItem: (key: string, value: string) => StorageEffect<void>;
/**
 * Delete an item from storage
 * @since 8.19.0
 * @category setters
 */
export declare const removeItem: (key: string) => StorageEffect<void>;
/**
 * A Layer for using sessionStorage for Storage
 * @since 8.19.0
 * @category context
 */
export declare const sessionStorage: Layer.Layer<Storage, never, Window>;
/**
 * A Layer for using localStorage for Storage
 * @since 8.19.0
 * @category context
 */
export declare const localStorage: Layer.Layer<Storage, never, Window>;
/**
 * SchemaStorage is a wrapper around Storage that allows you to store and retrieve values
 * that are parsed and encoded using a Schema. Given that storage is a string based key/value
 * store, this allows you to store and retrieve values that are not strings. JSON.stringify and
 * JSON.parse is used on the values to store and retrieve them.
 *
 * @since 8.19.0
 * @category models
 */
export interface SchemaStorage<Schemas extends Readonly<Record<string, S.Schema<any, string, any>>>> {
    readonly schemas: Schemas;
    readonly get: <K extends keyof Schemas & string>(key: K, options?: ParseOptions) => StorageEffect<O.Option<S.Schema.Type<Schemas[K]>>, ParseResult.ParseError, S.Schema.Context<Schemas[K]>>;
    readonly set: <K extends keyof Schemas & string>(key: K, value: S.Schema.Type<Schemas[K]>, options?: ParseOptions) => StorageEffect<void, ParseResult.ParseError, S.Schema.Context<Schemas[K]>>;
    readonly remove: <K extends keyof Schemas & string>(key: K) => StorageEffect<void>;
    readonly key: <K extends keyof Schemas & string>(key: K) => SchemaKeyStorage<S.Schema.Context<Schemas[K]>, S.Schema.Type<Schemas[K]>>;
}
/**
 * SchemaKeyStorage is effectively a lens into a specific key in a SchemaStorage.
 * It allows you to get/set/remove a value for a specific key.
 *
 * @since 8.19.0
 * @category models
 */
export interface SchemaKeyStorage<R, O> {
    readonly schema: S.Schema<O, string, R>;
    readonly get: (options?: ParseOptions) => StorageEffect<O.Option<O>, ParseResult.ParseError, R>;
    readonly set: (value: O, options?: ParseOptions) => StorageEffect<void, ParseResult.ParseError, R>;
    readonly remove: StorageEffect<void>;
}
/**
 * Construct a SchemaStorage
 * @since 8.19.0
 * @category constructors
 */
export declare function SchemaStorage<const Schemas extends Readonly<Record<string, S.Schema<any, string, any>>>>(schemas: Schemas): SchemaStorage<Schemas>;
/**
 * Construct a SchemaKeyStorage
 * @since 8.19.0
 * @category constructors
 */
export declare function SchemaKeyStorage<K extends string, R, O>(key: K, schema: S.Schema<O, string, R>): SchemaKeyStorage<R, O>;
/**
 * StorageEffect is a small extension of an Effect, which has 2 additional properties:
 * local and session. These are utilized to run the effect with either localStorage or
 * sessionStorage.
 *
 * @since 8.19.0
 * @category models
 */
export interface StorageEffect<A, E = never, R = never> extends Effect.Effect<A, E, Exclude<R, Storage> | Storage> {
    readonly local: Effect.Effect<A, E, Window | Exclude<R, Storage>>;
    readonly session: Effect.Effect<A, E, Window | Exclude<R, Storage>>;
}
/**
 * StorageEffect is a small extension of an Effect, which has 2 additional properties:
 * local and session. These are utilized to run the effect with either localStorage or
 * sessionStorage.
 *
 * @since 8.19.0
 * @category constructors
 */
export declare function StorageEffect<A, E, R>(effect: Effect.Effect<A, E, R>): StorageEffect<A, E, Exclude<R, Storage>>;
//# sourceMappingURL=Storage.d.ts.map