EventLog

declare function makeClient<Groups extends Any>(
  schema: EventLogSchema<Groups>,
): Effect<
  <Tag extends string>(
    event: Tag,
    payload: Type<
      PayloadSchema<
        Extract<
          Events<Groups>,
          {
            readonly tag: Tag;
          }
        >
      >
    >,
  ) => Effect<
    Type<
      SuccessSchema<
        Extract<
          Events<Groups>,
          {
            readonly tag: Tag;
          }
        >
      >
    >,
    | EventJournalError
    | Type<
        ErrorSchema<
          Extract<
            Events<Groups>,
            {
              readonly tag: Tag;
            }
          >
        >
      >
  >,
  never,
  EventLog
>;

declare function groupCompaction<Events extends Any, R>(
  group: EventGroup<Events>,
  effect: (options: {
    readonly entries: Array<Entry>;
    readonly events: Array<TaggedPayload<Events>>;
    readonly primaryKey: string;
    readonly write: <Tag extends string>(
      tag: Tag,
      payload: Type<
        PayloadSchema<
          Extract<
            Events,
            {
              readonly tag: Tag;
            }
          >
        >
      >,
    ) => Effect<void>;
  }) => Effect<void, never, R>,
): Layer<never, never, EventJournal | R | Identity | Context<Events>>;

declare function group<Events extends Any, Return>(
  group: EventGroup<Events>,
  f: (handlers: Handlers<never, Events>) => ValidateReturn<Return>,
): Layer<ToService<Events>, Error<Return>, Exclude<Context<Return>, Scope>>;

interface Handlers<R, Events extends Event.Any = never> extends Pipeable {
  readonly [HandlersTypeId]: {
    _Endpoints: Covariant<Events>;
  };
  readonly context: Context<any>;
  readonly group: AnyWithProps;
  readonly handlers: Record.ReadonlyRecord<string, Handlers.Item<R>>;
  handle<Tag extends string, R1>(
    name: Tag,
    handler: (options: {
      readonly conflicts: Array<{
        readonly entry: Entry;
        readonly payload: Type<
          PayloadSchema<
            Extract<
              Events,
              {
                readonly tag: Tag;
              }
            >
          >
        >;
      }>;
      readonly entry: Entry;
      readonly payload: Type<
        PayloadSchema<
          Extract<
            Events,
            {
              readonly tag: Tag;
            }
          >
        >
      >;
    }) => Effect<
      Type<
        SuccessSchema<
          Extract<
            Events,
            {
              readonly tag: Tag;
            }
          >
        >
      >,
      Type<
        ErrorSchema<
          Extract<
            Events,
            {
              readonly tag: Tag;
            }
          >
        >
      >,
      R1
    >,
  ): Handlers<
    R | R1,
    Exclude<
      Events,
      {
        readonly tag: Tag;
      }
    >
  >;
}

declare const HandlersTypeId: unique symbol;

type HandlersTypeId = typeof HandlersTypeId;

declare function layer<Groups extends Any>(
  _schema: EventLogSchema<Groups>,
): Layer<EventLog, never, EventJournal | Identity | ToService<Groups>>;

declare const layerEventLog: Layer.Layer<EventLog, never, EventJournal | Identity>;

declare function layerIdentityKvs(options: {
  readonly key: string;
}): Layer<Identity, any, KeyValueStore>;

declare class Registry extends any {
  constructor();
  static layer: Layer<unknown, never, never>;
}

declare function groupReactivity<Events extends Any>(group: EventGroup<Events>, keys: readonly Array<string> | { [Tag in string]: readonly Array<string> }): Layer<never, never, EventJournal | Identity>

interface EventLogSchema<Groups extends EventGroup.Any> {
  constructor(_: never);
  readonly [SchemaTypeId]: typeof SchemaTypeId;
  readonly groups: readonly Array<Groups>;
}

declare function isEventLogSchema(u: unknown): u is EventLogSchema<any>;

declare function schema<Groups extends readonly Array<Any>>(...groups: Groups): EventLogSchema<Groups[number]>

declare const SchemaTypeId: unique symbol;

type SchemaTypeId = typeof SchemaTypeId;

declare class EventLog extends any {
  constructor();
}

declare class Identity extends any {
  constructor();
  static readonly Schema: Struct<{
    readonly privateKey: Redacted<Uint8ArrayFromBase64>;
    readonly publicKey: String;
  }>;
  static readonly SchemaFromString: never;
  static decodeString(s: string): any;
  static encodeString(identity: any): string;
  static makeRandom(): any;
}