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;