declare class Entry

declare const EntryId: Schema.brand<typeof Schema.Uint8ArrayFromSelf, unique symbol>

type EntryId = typeof EntryId.Type

declare const EntryIdTypeId: unique symbol

declare class RemoteEntry

declare const entryIdMillis: (entryId: EntryId) => number

declare const makeEntryId: (options?: { msecs?: number }) => EntryId

declare const ErrorTypeId: unique symbol

type ErrorTypeId = typeof ErrorTypeId

declare class EventJournalError

readonly [ErrorTypeId]: unique symbol

declare const layerIndexedDb: (options?: { readonly database?: string }) => Layer.Layer<EventJournal, EventJournalError>

declare const makeIndexedDb: (options?: {
  readonly database?: string
}) => Effect.Effect<typeof EventJournal.Service, EventJournalError, Scope>

declare const layerMemory: Layer.Layer<EventJournal, never, never>

declare const makeMemory: Effect.Effect<
  {
    readonly entries: Effect.Effect<ReadonlyArray<Entry>, EventJournalError>
    readonly write: <A, E, R>(options: {
      readonly event: string
      readonly primaryKey: string
      readonly payload: Uint8Array
      readonly effect: (entry: Entry) => Effect.Effect<A, E, R>
    }) => Effect.Effect<A, EventJournalError | E, R>
    readonly writeFromRemote: (options: {
      readonly remoteId: RemoteId
      readonly entries: ReadonlyArray<RemoteEntry>
      readonly compact?:
        | ((
            uncommitted: ReadonlyArray<RemoteEntry>
          ) => Effect.Effect<
            ReadonlyArray<[compacted: ReadonlyArray<Entry>, remoteEntries: ReadonlyArray<RemoteEntry>]>,
            EventJournalError
          >)
        | undefined
      readonly effect: (options: {
        readonly entry: Entry
        readonly conflicts: ReadonlyArray<Entry>
      }) => Effect.Effect<void, EventJournalError>
    }) => Effect.Effect<void, EventJournalError>
    readonly withRemoteUncommited: <A, E, R>(
      remoteId: RemoteId,
      f: (entries: ReadonlyArray<Entry>) => Effect.Effect<A, E, R>
    ) => Effect.Effect<A, EventJournalError | E, R>
    readonly nextRemoteSequence: (remoteId: RemoteId) => Effect.Effect<number, EventJournalError>
    readonly changes: Effect.Effect<Queue.Dequeue<Entry>, never, Scope>
    readonly destroy: Effect.Effect<void, EventJournalError>
  },
  never,
  never
>

declare const RemoteId: Schema.brand<typeof Schema.Uint8ArrayFromSelf, unique symbol>

type RemoteId = typeof RemoteId.Type

declare const RemoteIdTypeId: unique symbol

declare const makeRemoteId: () => RemoteId

declare class EventJournal