EventJournal

declare class Entry extends {
  [key: string]: any;
} {
  [key: string]: any;
  constructor(...args: [props?: {
    [key: string]: any;
  }, options?: MakeOptions]);
  static arrayMsgPack: $Array<any>;
  static decodeArray: (self: Constraint) => decodeTo<toType<Constraint>, Constraint, never, never>;
  static encodeArray: (self: Constraint) => decodeTo<Constraint, toEncoded<Constraint>, never, never>;
  createdAt: Utc;
  createdAtMillis: number;
  idString: string;
}

declare const EntryId: any;

type EntryId = typeof EntryId.Type;

declare function entryIdMillis(entryId: any): number;

declare const EntryIdTypeId: unique symbol;

declare function makeEntryId(options: { msecs?: number }): any;

declare class RemoteEntry extends ReadonlySide<
  {
    readonly entry: typeof Entry;
    readonly remoteSequence: Number;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly entry: typeof Entry;
        readonly remoteSequence: Number;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare const ErrorTypeId: unique symbol;

type ErrorTypeId = typeof ErrorTypeId;

declare class EventJournalError extends ReadonlySide<
  {
    [key: string]: Constraint;
    [key: number]: Constraint;
    [key: symbol]: Constraint;
    readonly _tag: tag<"EventJournalError">;
  },
  "Type"
> {
  [key: string]: unknown;
  [key: number]: unknown;
  [key: symbol]: unknown;
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        [key: string]: Constraint;
        [key: number]: Constraint;
        [key: symbol]: Constraint;
        readonly _tag: tag<"EventJournalError">;
      }>,
      options?: MakeOptions,
    ]
  );
  readonly [ErrorTypeId]: typeof ErrorTypeId;
}

declare function layerIndexedDb(options?: {
  readonly database?: string;
}): Layer<EventJournal, EventJournalError>;

declare function makeIndexedDb(options?: {
  readonly database?: string;
}): Effect<any, EventJournalError, Scope>;

declare const layerMemory: Layer.Layer<EventJournal>;

declare const makeMemory: Effect.Effect<typeof EventJournal.Service>;

declare function makeRemoteId(): any;

declare const RemoteId: any;

type RemoteId = typeof RemoteId.Type;

declare const RemoteIdTypeId: unique symbol;

declare class EventJournal extends any {
  constructor();
}