Workflow

declare class CaptureDefects extends any {
  constructor();
}

declare class SuspendOnFailure extends any {
  constructor();
}

declare const withCompensation: {
  <A, R2>(
    compensation: (value: A, cause: Cause<unknown>) => Effect<void, never, R2>,
  ): <E, R>(effect: Effect<A, E, R>) => Effect<A, E, WorkflowInstance | Scope | R2 | R>;
  <A, E, R, R2>(
    effect: Effect<A, E, R>,
    compensation: (value: A, cause: Cause<unknown>) => Effect<void, never, R2>,
  ): Effect<A, E, WorkflowInstance | Scope | R | R2>;
};

interface AnyTaggedRequestSchema extends AnyStructSchema {
  [key: number]: any;
  readonly _tag: string;
  readonly failure: All;
  readonly success: Any;
  readonly Type: PrimaryKey;
}

declare function fromTaggedRequest<S extends AnyTaggedRequestSchema>(
  schema: S,
  options?: {
    readonly suspendedRetrySchedule?: Schedule<any, unknown, never, never>;
  },
): Workflow<S["_tag"], S, S["success"], S["failure"]>;

declare function make<
  Name extends string,
  Payload extends Fields | AnyStructSchema,
  Success extends Any = Void,
  Error extends All = Never,
>(options: {
  readonly annotations?: Context<never>;
  readonly error?: Error;
  readonly idempotencyKey: (
    payload: Payload extends Fields
      ? View<Payload, "Type", TypeOptionalKeys<Payload>, TypeMutableKeys<Payload>>
      : Payload["Type"],
  ) => string;
  readonly name: Name;
  readonly payload: Payload;
  readonly success?: Success;
  readonly suspendedRetrySchedule?: Schedule<any, unknown, never, never>;
}): Workflow<Name, Payload extends Fields ? Struct<Payload> : Payload, Success, Error>;

interface Any {
  readonly [TypeId]: typeof TypeId;
  readonly annotations: Context<never>;
  readonly errorSchema: All;
  readonly executionId: (payload: any) => Effect<string>;
  readonly name: string;
  readonly payloadSchema: AnyStructSchema;
  readonly successSchema: Any;
}

interface Execution<Name extends string> {
  readonly _: typeof _;
  readonly name: Name;
}

type Requirements<Workflows extends Any> =
  Workflows extends Workflow<infer _Name, infer _Payload, infer _Success, infer _Error>
    ? _Payload["Context"] | _Success["Context"] | _Error["Context"]
    : never;

interface Workflow<
  Name extends string,
  Payload extends AnyStructSchema,
  Success extends Schema.Schema.Any,
  Error extends Schema.Schema.All,
> {
  readonly [TypeId]: typeof TypeId;
  readonly annotations: Context<never>;
  readonly errorSchema: Error;
  readonly execute: <Discard extends boolean = false>(
    payload: [keyof Payload["fields"]] extends [never]
      ? void
      : Simplify<Constructor<Payload["fields"]>>,
    options?: {
      readonly discard?: Discard;
    },
  ) => Effect<
    Discard extends true ? string : Success["Type"],
    Discard extends true ? never : Error["Type"],
    WorkflowEngine | Payload["Context"] | Success["Context"] | Error["Context"]
  >;
  readonly executionId: (payload: Simplify<Constructor<Payload["fields"]>>) => Effect<string>;
  readonly interrupt: (executionId: string) => Effect<void, never, WorkflowEngine>;
  readonly name: Name;
  readonly payloadSchema: Payload;
  readonly poll: (
    executionId: string,
  ) => Effect<
    Result<Success["Type"], Error["Type"]> | undefined,
    never,
    WorkflowEngine | Success["Context"] | Error["Context"]
  >;
  readonly resume: (executionId: string) => Effect<void, never, WorkflowEngine>;
  readonly successSchema: Success;
  readonly toLayer: <R>(
    execute: (
      payload: Payload["Type"],
      executionId: string,
    ) => Effect<Success["Type"], Error["Type"], R>,
  ) => Layer<
    never,
    never,
    | WorkflowEngine
    | Payload["Context"]
    | Success["Context"]
    | Error["Context"]
    | Exclude<R, WorkflowEngine | WorkflowInstance | Scope | Execution<Name>>
  >;
  readonly withCompensation: {
    <A, R2>(
      compensation: (value: A, cause: Cause<Error["Type"]>) => Effect<void, never, R2>,
    ): <E, R>(
      effect: Effect<A, E, R>,
    ) => Effect<A, E, WorkflowInstance | Scope | Execution<Name> | R2 | R>;
    <A, E, R, R2>(
      effect: Effect<A, E, R>,
      compensation: (value: A, cause: Cause<Error["Type"]>) => Effect<void, never, R2>,
    ): Effect<A, E, WorkflowInstance | Scope | Execution<Name> | R | R2>;
  };
  annotate<I, S>(tag: Tag<I, S>, value: S): Workflow<Name, Payload, Success, Error>;
  annotateContext<I>(context: Context<I>): Workflow<Name, Payload, Success, Error>;
}

interface AnyStructSchema extends Pipeable {
  [key: number]: any;
  readonly annotations: any;
  readonly ast: AST;
  readonly Context: any;
  readonly Encoded: any;
  readonly fields: Fields;
  readonly make: any;
  readonly Type: any;
}

declare function suspend(instance: any): Effect<never>;

declare class Complete<A, E> extends Readonly<{
  readonly exit: Exit<A, E>;
}> & {
  readonly _tag: "Complete";
} & Pipeable {
  constructor<A, E>(args: {
    readonly exit: Exit<A, E>;
  });
  readonly [ResultTypeId]: typeof ResultTypeId;
  static Schema<Success extends Any, Error extends All>(options: {
    readonly error: Error;
    readonly success: Success;
  }): any;
  static SchemaEncoded<Success extends Any, Error extends All>(options: {
    readonly error: Error;
    readonly success: Success;
  }): Struct<{
    readonly _tag: tag<"Complete">;
    readonly exit: Exit<Constraint, Constraint, Constraint>;
  }>;
  static SchemaFromSelf<Success extends Any, Error extends All>(_options: {
    readonly error: Error;
    readonly success: Success;
  }): Schema<Complete<Success["Type"], Error["Type"]>>;
}

interface CompleteEncoded<A, E> {
  readonly _tag: "Complete";
  readonly exit: ExitEncoded<A, E, unknown>;
}

declare function intoResult<A, E, R>(
  effect: Effect<A, E, R>,
): Effect<Result<A, E>, never, WorkflowInstance | Exclude<R, Scope>>;

declare function isResult<A = unknown, E = unknown>(u: unknown): u is Result<A, E>;

declare const Result: <Success extends Any, Error extends All>(options: {
  readonly error: Error;
  readonly success: Success;
}) => any;

type Result<A, E> = Complete<A, E> | Suspended;

type ResultEncoded<A, E> = CompleteEncoded<A, E> | typeof Suspended.Encoded;

declare const ResultTypeId: unique symbol;

type ResultTypeId = typeof ResultTypeId;

declare class Suspended extends {
  readonly _tag: "Suspended";
  readonly cause?: Cause<unknown>;
} {
  constructor(...args: [props?: {
    readonly _tag?: "Suspended";
    readonly cause?: Cause<unknown>;
  }, options?: MakeOptions]);
  readonly [ResultTypeId]: typeof ResultTypeId;
}

declare function wrapActivityResult<A, E, R>(
  effect: Effect<A, E, R>,
  isSuspend: (value: A) => boolean,
): Effect<A, E, WorkflowInstance | R>;

declare const addFinalizer: <R>(
  f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R>,
) => Effect.Effect<void, never, WorkflowInstance | R>;

declare function provideScope<A, E, R>(
  effect: Effect<A, E, R>,
): Effect<A, E, WorkflowInstance | Exclude<R, Scope>>;

declare const scope: Effect.Effect<Scope.Scope, never, WorkflowInstance>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;