export declare const empty: EventGroup<never>

export declare const isEventGroup: (u: unknown) => u is EventGroup.Any

export interface EventGroup<out Events extends Event.Any = never> extends Pipeable {
  new (_: never): {}

  readonly [TypeId]: TypeId
  readonly events: Record.ReadonlyRecord<string, Events>

  /**
   * Add an `Event` to the `EventGroup`.
   */
  add<
    Tag extends string,
    Payload extends Schema.Schema.Any = typeof Schema.Void,
    Success extends Schema.Schema.Any = typeof Schema.Void,
    Error extends Schema.Schema.All = typeof Schema.Never
  >(options: {
    readonly tag: Tag
    readonly primaryKey: (payload: Schema.Schema.Type<Payload>) => string
    readonly payload?: Payload
    readonly success?: Success
    readonly error?: Error
  }): EventGroup<Events | Event<Tag, Payload, Success, Error>>

  /**
   * Add an error schema to all the events in the `EventGroup`.
   */
  addError<Error extends Schema.Schema.Any>(error: Error): EventGroup<Event.AddError<Events, Error>>
}

export interface Any {
  readonly [TypeId]: TypeId
}

export type AnyWithProps = EventGroup<Event.AnyWithProps>

export type Context<Group> = Event.Context<Events<Group>>

export type Events<Group> = Group extends EventGroup<infer _Events> ? _Events : never

export type ToService<A> = A extends EventGroup<infer _Events> ? Event.ToService<_Events> : never

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId