KeyValueStore

declare const prefix: {
  (prefix: string): <S extends AnyStore>(self: S) => S;
  <S extends AnyStore>(self: S, prefix: string): S;
}

declare const make: (impl: Omit<KeyValueStore, typeof TypeId | "has" | "modify" | "modifyUint8Array" | "isEmpty" | "forSchema"> & Partial<KeyValueStore>) => KeyValueStore

declare const makeStringOnly: (impl: Pick<KeyValueStore, "get" | "remove" | "clear" | "size"> & Partial<Omit<KeyValueStore, "set">> & {
  readonly set: (key: string, value: string) => Effect.Effect<void, PlatformError.PlatformError>;
}) => KeyValueStore

declare const layerFileSystem: (directory: string) => Layer.Layer<KeyValueStore, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path>

declare const layerMemory: Layer.Layer<KeyValueStore>

declare const layerSchema: <A, I, R>(schema: Schema.Schema<A, I, R>, tagIdentifier: string) => {
  readonly layer: Layer.Layer<SchemaStore<A, R>, never, KeyValueStore>;
  readonly tag: Context.Tag<SchemaStore<A, R>, SchemaStore<A, R>>;
}

declare const layerStorage: (evaluate: LazyArg<Storage>) => Layer.Layer<KeyValueStore>

interface KeyValueStore {
  readonly [TypeId]: typeof TypeId;
  readonly clear: Effect<void, PlatformError>;
  readonly forSchema: <A, I, R>(schema: any) => SchemaStore<A, R>;
  readonly get: (key: string) => Effect<Option<string>, PlatformError>;
  readonly getUint8Array: (key: string) => Effect<Option<Uint8Array<ArrayBufferLike>>, PlatformError>;
  readonly has: (key: string) => Effect<boolean, PlatformError>;
  readonly isEmpty: Effect<boolean, PlatformError>;
  readonly modify: (key: string, f: (value: string) => string) => Effect<Option<string>, PlatformError>;
  readonly modifyUint8Array: (key: string, f: (value: Uint8Array) => Uint8Array) => Effect<Option<Uint8Array<ArrayBufferLike>>, PlatformError>;
  readonly remove: (key: string) => Effect<void, PlatformError>;
  readonly set: (key: string, value: string | Uint8Array<ArrayBufferLike>) => Effect<void, PlatformError>;
  readonly size: Effect<number, PlatformError>;
}

interface SchemaStore<A, R> {
  readonly [SchemaStoreTypeId]: typeof SchemaStoreTypeId;
  readonly clear: Effect<void, PlatformError>;
  readonly get: (key: string) => Effect<Option<A>, any, R>;
  readonly has: (key: string) => Effect<boolean, PlatformError>;
  readonly isEmpty: Effect<boolean, PlatformError>;
  readonly modify: (key: string, f: (value: A) => A) => Effect<Option<A>, any, R>;
  readonly remove: (key: string) => Effect<void, PlatformError>;
  readonly set: (key: string, value: A) => Effect<void, any, R>;
  readonly size: Effect<number, PlatformError>;
}

declare const KeyValueStore: Tag<KeyValueStore, KeyValueStore>

declare const SchemaStoreTypeId: unique symbol

type SchemaStoreTypeId = typeof SchemaStoreTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId