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 any {
  constructor();
  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;