declare const retry: {
  <M extends Machine.Any, Out, In extends Machine.InitError<M> | MachineDefect, R>(
    policy: Schedule.Schedule<Out, In, R>
  ): (self: M) => Machine.AddContext<M, R>
  <M extends Machine.Any, Out, In extends Machine.InitError<M> | MachineDefect, R>(
    self: M,
    policy: Schedule.Schedule<Out, In, R>
  ): Machine.AddContext<M, R>
}

declare const make: {
  <State, Public extends Procedure.TaggedRequest.Any, Private extends Procedure.TaggedRequest.Any, InitErr, R>(
    initialize: Effect.Effect<ProcedureList<State, Public, Private, R>, InitErr, R>
  ): Machine<State, Public, Private, void, InitErr, Exclude<R, Scope.Scope | MachineContext>>
  <State, Public extends Procedure.TaggedRequest.Any, Private extends Procedure.TaggedRequest.Any, Input, InitErr, R>(
    initialize: Machine.Initialize<Input, State, Public, Private, R, InitErr, R>
  ): Machine<State, Public, Private, Input, InitErr, Exclude<R, Scope.Scope | MachineContext>>
}

declare const makeSerializable: {
  <State, IS, RS, Public extends Schema.TaggedRequest.All, Private extends Schema.TaggedRequest.All, InitErr, R>(
    options: { readonly state: Schema.Schema<State, IS, RS>; readonly input?: undefined },
    initialize:
      | Effect.Effect<SerializableProcedureList<State, Public, Private, R>, InitErr, R>
      | Machine.InitializeSerializable<void, State, Public, Private, R, InitErr, R>
  ): SerializableMachine<State, Public, Private, void, InitErr, Exclude<R, Scope.Scope | MachineContext>, RS>
  <
    State,
    IS,
    RS,
    Input,
    II,
    RI,
    Public extends Schema.TaggedRequest.All,
    Private extends Schema.TaggedRequest.All,
    InitErr,
    R
  >(
    options: { readonly state: Schema.Schema<State, IS, RS>; readonly input: Schema.Schema<Input, II, RI> },
    initialize: Machine.InitializeSerializable<Input, State, Public, Private, R, InitErr, R>
  ): SerializableMachine<State, Public, Private, Input, InitErr, Exclude<R, Scope.Scope | MachineContext>, RS | RI>
}

declare const makeWith: <State, Input = void>() => {
  <Public extends Procedure.TaggedRequest.Any, Private extends Procedure.TaggedRequest.Any, InitErr, R>(
    initialize: Effect.Effect<ProcedureList<State, Public, Private, R>, InitErr, R>
  ): Machine<State, Public, Private, void, InitErr, Exclude<R, Scope.Scope | MachineContext>>
  <Public extends Procedure.TaggedRequest.Any, Private extends Procedure.TaggedRequest.Any, InitErr, R>(
    initialize: Machine.Initialize<Input, State, Public, Private, R, InitErr, R>
  ): Machine<State, Public, Private, Input, InitErr, Exclude<R, Scope.Scope | MachineContext>>
}

declare class MachineDefect

declare const wrap: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, MachineDefect, R>

export interface Actor<M extends Machine.Any> extends Subscribable.Subscribable<Machine.State<M>> {
  readonly [ActorTypeId]: ActorTypeId
  readonly machine: M
  readonly input: Machine.Input<M>
  readonly send: <Req extends Machine.Public<M>>(
    request: Req
  ) => Effect.Effect<Request.Success<Req>, Request.Error<Req>>
  readonly join: Effect.Effect<never, Machine.InitError<M> | MachineDefect>
}

export interface Machine<
  State,
  Public extends Procedure.TaggedRequest.Any,
  Private extends Procedure.TaggedRequest.Any,
  Input,
  InitErr,
  R
> extends Pipeable {
  readonly [TypeId]: TypeId
  readonly initialize: Machine.Initialize<Input, State, Public, Private, R, InitErr, R>
  readonly retryPolicy: Schedule.Schedule<unknown, InitErr | MachineDefect, R> | undefined
}

type Any =
  | Machine<any, any, any, any, any, any>
  | Machine<any, any, any, any, never, any>
  | Machine<any, never, any, any, never, any>
  | Machine<any, any, never, any, never, any>
  | Machine<any, never, never, any, never, any>

type Initialize<Input, State, Public, Private, R, E, InitR> = (
  input: Input,
  previousState?: State | undefined
) => Effect.Effect<ProcedureList<State, Public, Private, R>, E, InitR>

type InitializeSerializable<Input, State, Public, Private, R, E, InitR> = (
  input: Input,
  previousState?: State | undefined
) => Effect.Effect<SerializableProcedureList<State, Public, Private, R>, E, InitR>

type Public<M> = M extends Machine<infer _S, infer Public, infer _Pr, infer _I, infer _IE, infer _R> ? Public : never

type Private<M> = M extends Machine<infer _S, infer _Pu, infer Private, infer _I, infer _IE, infer _R> ? Private : never

type State<M> = M extends Machine<infer State, infer _Pu, infer _Pr, infer _I, infer _IE, infer _R> ? State : never

type InitError<M> =
  M extends Machine<infer _S, infer _Pu, infer _Pr, infer _I, infer InitErr, infer _R> ? InitErr : never

type Context<M> = M extends Machine<infer _S, infer _Pu, infer _Pr, infer _I, infer _IE, infer R> ? R : never

type Input<M> = M extends Machine<infer _S, infer _Pu, infer _Pr, infer Input, infer _IE, infer _R> ? Input : never

type AddContext<M, R, E> =
  M extends SerializableMachine<
    infer State,
    infer Public,
    infer Private,
    infer Input,
    infer InitErr,
    infer R2,
    infer SR
  >
    ? SerializableMachine<State, Public, Private, Input, InitErr | E, R | R2, SR>
    : M extends Machine<infer State, infer Public, infer Private, infer Input, infer InitErr, infer R2>
      ? Machine<State, Public, Private, Input, InitErr | E, R | R2>
      : never

export interface SerializableActor<M extends Machine.Any> extends Actor<M> {
  readonly sendUnknown: (
    request: unknown
  ) => Effect.Effect<Schema.ExitEncoded<unknown, unknown, unknown>, ParseResult.ParseError>
}

export interface SerializableMachine<
  State,
  Public extends Schema.TaggedRequest.All,
  Private extends Schema.TaggedRequest.All,
  Input,
  InitErr,
  R,
  SR
> extends Machine<State, Public, Private, Input, InitErr, R> {
  readonly [SerializableTypeId]: SerializableTypeId
  readonly schemaInput: Schema.Schema<Input, unknown, SR>
  readonly schemaState: Schema.Schema<State, unknown, SR>
}

export * as procedures from "./Machine/ProcedureList.js"

export * as serializable from "./Machine/SerializableProcedureList.js"

declare const boot: <M extends Machine.Any>(
  self: M,
  ...[input, options]: [Machine.Input<M>] extends [void]
    ? [input?: Machine.Input<M>, options?: { readonly previousState?: Machine.State<M> }]
    : [input: Machine.Input<M>, options?: { readonly previousState?: Machine.State<M> }]
) => Effect.Effect<
  M extends { readonly [SerializableTypeId]: SerializableTypeId } ? SerializableActor<M> : Actor<M>,
  never,
  Machine.Context<M> | Scope.Scope
>

declare const restore: <
  State,
  Public extends Schema.TaggedRequest.All,
  Private extends Schema.TaggedRequest.All,
  Input,
  InitErr,
  R,
  SR
>(
  self: SerializableMachine<State, Public, Private, Input, InitErr, R, SR>,
  snapshot: readonly [input: unknown, state: unknown]
) => Effect.Effect<
  Actor<SerializableMachine<State, Public, Private, Input, InitErr, R, SR>>,
  ParseResult.ParseError,
  R | SR
>

declare const snapshot: <
  State,
  Public extends Schema.TaggedRequest.All,
  Private extends Schema.TaggedRequest.All,
  Input,
  InitErr,
  R,
  SR
>(
  self: Actor<SerializableMachine<State, Public, Private, Input, InitErr, R, SR>>
) => Effect.Effect<[input: unknown, state: unknown], ParseResult.ParseError, SR>

declare const NoReply: unique symbol

declare class MachineContext

declare const currentTracingEnabled: FiberRef.FiberRef<boolean>

declare const withTracingEnabled: {
  (enabled: boolean): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(effect: Effect.Effect<A, E, R>, enabled: boolean): Effect.Effect<A, E, R>
}

declare const ActorTypeId: unique symbol

type ActorTypeId = typeof ActorTypeId

declare const SerializableTypeId: unique symbol

type SerializableTypeId = typeof SerializableTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId