Machine

declare const retry: {
  <M extends Any, Out, In extends any, R>(policy: Schedule<Out, In, R>): (self: M) => AddContext<M, R>;
  <M extends Any, Out, In extends any, R>(self: M, policy: Schedule<Out, In, R>): AddContext<M, R>;
}

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

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

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

declare class MachineDefect extends {
  [key: string]: unknown;
  [key: number]: unknown;
  [key: symbol]: unknown;
  readonly _tag: "MachineDefect";
} & YieldableError<this> {
  [key: string]: unknown;
  [key: number]: unknown;
  [key: symbol]: unknown;
  constructor(...args: [props: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
    readonly _tag: "MachineDefect";
  }, options?: MakeOptions]);
  static wrap<A, E, R>(effect: Effect<A, E, R>): Effect<A, MachineDefect, R>;
}

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

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

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

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]: typeof SerializableTypeId;
  readonly schemaInput: any;
  readonly schemaState: any;
}

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

declare function restore<State, Public extends All, Private extends All, Input, InitErr, R, SR>(self: SerializableMachine<State, Public, Private, Input, InitErr, R, SR>, snapshot: readonly [unknown, unknown]): Effect<Actor<SerializableMachine<State, Public, Private, Input, InitErr, R, SR>>, ParseError, R | SR>

declare function snapshot<State, Public extends All, Private extends All, Input, InitErr, R, SR>(self: Actor<SerializableMachine<State, Public, Private, Input, InitErr, R, SR>>): Effect<[input: unknown, state: unknown], ParseError, SR>

declare const NoReply: typeof NoReply

type NoReply = typeof NoReply

declare class MachineContext extends any {
  constructor();
}

declare const currentTracingEnabled: FiberRef.FiberRef<boolean>

declare const withTracingEnabled: {
  (enabled: boolean): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R>(effect: Effect<A, E, R>, enabled: boolean): 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