export 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, never>
  <M extends Machine.Any, Out, In extends MachineDefect | Machine.InitError<M>, R>(
    self: M,
    policy: Schedule.Schedule<Out, In, R>
  ): Machine.AddContext<M, R, never>
}

export 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, any>>
  <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, any>>
}

export declare const makeSerializable: {
  <State, IS, RS, Public extends Schema.TaggedRequest.Any, Private extends Schema.TaggedRequest.Any, InitErr, R>(
    options: { readonly state: Schema.Schema<State, IS, RS>; readonly input?: undefined },
    initialize: any
  ): SerializableMachine<State, Public, Private, void, InitErr, Exclude<R, any>, RS>
  <
    State,
    IS,
    RS,
    Input,
    II,
    RI,
    Public extends Schema.TaggedRequest.Any,
    Private extends Schema.TaggedRequest.Any,
    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, any>, RS | RI>
}

export 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, any>>
  <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, any>>
}

export declare class MachineDefect

static 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, InitErr, R, R>
  readonly retryPolicy: Schedule.Schedule<unknown, InitErr | MachineDefect, R> | undefined
}

export type AddContext<M, R, E = never> =
  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 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>

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

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

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

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

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

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

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

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

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

export interface SerializableMachine<
  State,
  Public extends Schema.TaggedRequest.Any,
  Private extends Schema.TaggedRequest.Any,
  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"

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

export declare const restore: <
  State,
  Public extends Schema.TaggedRequest.Any,
  Private extends Schema.TaggedRequest.Any,
  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
>

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

export declare const NoReply: typeof Procedure.NoReply

export declare class MachineContext

export declare const currentTracingEnabled: FiberRef.FiberRef<boolean>

export 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>
}

export declare const ActorTypeId: typeof ActorTypeId

export type ActorTypeId = typeof ActorTypeId

export declare const SerializableTypeId: typeof SerializableTypeId

export type SerializableTypeId = typeof SerializableTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId