utils

export declare function Attempted(version: string)

export interface Attempted {
  _tag: typeof ATTEMPTED
  sequence: number
  version: string
}

export declare function Completed<A, E>(exit: Exit.Exit<A, E>)

export interface Completed<A, E> {
  _tag: typeof COMPLETED
  sequence: number
  exit: Exit.Exit<A, E>
}

export type DurableExecutionEvent<A, E> = Attempted | InterruptionRequested | Completed<A, E> | Forked | Joined

export type DurableExecutionEventFrom<IE, IA> =
  | {
      readonly _tag: typeof ATTEMPTED
      readonly sequence: number
      readonly version: string
    }
  | {
      readonly _tag: typeof INTERRUPTION_REQUESTED
      readonly sequence: number
    }
  | {
      readonly _tag: typeof COMPLETED
      readonly sequence: number
      readonly exit: Schema.ExitEncoded<IE, IA, unknown>
    }
  | {
      readonly _tag: typeof FORKED
      readonly sequence: number
      readonly persistenceId: string
    }
  | {
      readonly _tag: typeof JOINED
      readonly sequence: number
      readonly persistenceId: string
    }

export declare function Forked(persistenceId: string)

export interface Forked {
  _tag: typeof FORKED
  sequence: number
  persistenceId: string
}

export interface InterruptionRequested {
  _tag: typeof INTERRUPTION_REQUESTED
  sequence: number
}

export declare function Joined(persistenceId: string)

export interface Joined {
  _tag: typeof JOINED
  sequence: number
  persistenceId: string
}

export declare function KillRequested(sequence: number): DurableExecutionEvent<never, never>

export declare function match<A, E, B, C = B, D = C, F = D, G = F>(
  event: DurableExecutionEvent<A, E>,
  fns: {
    onAttempted: (event: Attempted) => B
    onInterruptionRequested: (event: InterruptionRequested) => C
    onCompleted: (event: Completed<A, E>) => D
    onForked: (event: Forked) => F
    onJoined: (event: Joined) => G
  }
)

export declare function schema<A, IA, E, IE>(
  success: Schema.Schema<A, IA>,
  failure: Schema.Schema<E, IE>
): Schema.Schema<DurableExecutionEvent<A, E>, DurableExecutionEventFrom<IA, IE>>