WorkflowEngine

declare function makeUnsafe(options: Encoded): any;

interface Encoded {
  readonly activityExecute: (
    activity: Any,
    attempt: number,
  ) => Effect<Result<unknown, unknown>, never, WorkflowInstance>;
  readonly deferredDone: (options: {
    readonly deferredName: string;
    readonly executionId: string;
    readonly exit: Exit<unknown, unknown>;
    readonly workflowName: string;
  }) => Effect<void>;
  readonly deferredResult: (
    deferred: Any,
  ) => Effect<Exit<unknown, unknown> | undefined, never, WorkflowInstance>;
  readonly execute: <Discard extends boolean>(
    workflow: Any,
    options: {
      readonly discard: Discard;
      readonly executionId: string;
      readonly parent?: any;
      readonly payload: object;
    },
  ) => Effect<Discard extends true ? void : Result<unknown, unknown>>;
  readonly interrupt: (workflow: Any, executionId: string) => Effect<void>;
  readonly poll: (
    workflow: Any,
    executionId: string,
  ) => Effect<Result<unknown, unknown> | undefined>;
  readonly register: (
    workflow: Any,
    execute: (
      payload: object,
      executionId: string,
    ) => Effect<unknown, unknown, WorkflowEngine | WorkflowInstance>,
  ) => Effect<void, never, Scope>;
  readonly resume: (workflow: Any, executionId: string) => Effect<void>;
  readonly scheduleClock: (
    workflow: Any,
    options: {
      readonly clock: DurableClock;
      readonly executionId: string;
    },
  ) => Effect<void>;
}

declare const layerMemory: Layer.Layer<WorkflowEngine>;

declare class WorkflowEngine extends any {
  constructor();
}

declare class WorkflowInstance extends any {
  constructor();
  static initial(workflow: Any, executionId: string): any;
}