DurableDeferred

declare const done: {
  <Success extends Any, Error extends All>(options: {
    readonly exit: Exit.Exit<Success["Type"], Error["Type"]>;
    readonly token: Token;
  }): (
    self: DurableDeferred<Success, Error>,
  ) => Effect<void, never, WorkflowEngine | Success["Context"] | Error["Context"]>;
  <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
    options: {
      readonly exit: Exit.Exit<Success["Type"], Error["Type"]>;
      readonly token: Token;
    },
  ): Effect<void, never, WorkflowEngine | Success["Context"] | Error["Context"]>;
};

declare const fail: {
  <Success extends Any, Error extends All>(options: {
    readonly error: Error["Type"];
    readonly token: Token;
  }): (
    self: DurableDeferred<Success, Error>,
  ) => Effect<void, never, WorkflowEngine | Error["Context"]>;
  <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
    options: {
      readonly error: Error["Type"];
      readonly token: Token;
    },
  ): Effect<void, never, WorkflowEngine | Error["Context"]>;
};

declare const failCause: {
  <Success extends Any, Error extends All>(options: {
    readonly cause: Cause.Cause<Error["Type"]>;
    readonly token: Token;
  }): (
    self: DurableDeferred<Success, Error>,
  ) => Effect<void, never, WorkflowEngine | Error["Context"]>;
  <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
    options: {
      readonly cause: Cause.Cause<Error["Type"]>;
      readonly token: Token;
    },
  ): Effect<void, never, WorkflowEngine | Error["Context"]>;
};

declare const into: {
  <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
  ): <R>(
    effect: Effect<Success["Type"], Error["Type"], R>,
  ) => Effect<
    Success["Type"],
    Error["Type"],
    WorkflowEngine | WorkflowInstance | R | Success["Context"] | Error["Context"]
  >;
  <Success extends Any, Error extends All, R>(
    effect: Effect<Success["Type"], Error["Type"], R>,
    self: DurableDeferred<Success, Error>,
  ): Effect<
    Success["Type"],
    Error["Type"],
    WorkflowEngine | WorkflowInstance | R | Success["Context"] | Error["Context"]
  >;
};

declare const succeed: {
  <Success extends Any, Error extends All>(options: {
    readonly token: Token;
    readonly value: Success["Type"];
  }): (
    self: DurableDeferred<Success, Error>,
  ) => Effect<void, never, WorkflowEngine | Success["Context"]>;
  <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
    options: {
      readonly token: Token;
      readonly value: Success["Type"];
    },
  ): Effect<void, never, WorkflowEngine | Success["Context"]>;
};

declare function make<Success extends Any = Void, Error extends All = Never>(
  name: string,
  options?: {
    readonly error?: Error;
    readonly success?: Success;
  },
): DurableDeferred<Success, Error>;

interface Any {
  readonly [TypeId]: typeof TypeId;
  readonly errorSchema: All;
  readonly exitSchema: ExitFromSelf<any, any, any>;
  readonly name: string;
  readonly successSchema: Any;
}

interface DurableDeferred<
  Success extends Schema.Schema.Any,
  Error extends Schema.Schema.All = typeof Schema.Never,
> {
  readonly [TypeId]: typeof TypeId;
  readonly errorSchema: Error;
  readonly exitSchema: ExitFromSelf<Success, Error, (options?: ErrorOptions) => Defect>;
  readonly name: string;
  readonly successSchema: Success;
  readonly withActivityAttempt: Effect<DurableDeferred<Success, Error>>;
}

declare const await: <Success extends Schema.Schema.Any, Error extends Schema.Schema.All>(
  self: DurableDeferred<Success, Error>,
) => Effect.Effect<
  Success["Type"],
  Error["Type"],
  WorkflowEngine | WorkflowInstance | Success["Context"] | Error["Context"]
>;

declare function raceAll<
  Effects extends readonly [Effect<any, any, any>, Effect<any, any, any>],
  SI,
  SR,
  EI,
  ER,
>(options: {
  effects: Effects;
  error: any;
  name: string;
  success: any;
}): Effect<
  Effects[number] extends Effect<_A, _E, _R> ? _A : never,
  Effects[number] extends Effect<_A, _E, _R> ? _E : never,
  WorkflowEngine | WorkflowInstance | SR | ER | Effects[number] extends Effect<_A, _R, R>
    ? R
    : never
>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;

declare const token: <Success extends Schema.Schema.Any, Error extends Schema.Schema.All>(
  self: DurableDeferred<Success, Error>,
) => Effect.Effect<Token, never, WorkflowInstance>;

declare const Token: brand<String, typeof TokenTypeId>;

type Token = Brand.Branded<string, TokenTypeId>;

declare const tokenFromExecutionId: {
  (options: {
    readonly executionId: string;
    readonly workflow: Workflow.Any;
  }): <Success extends Any, Error extends All>(self: DurableDeferred<Success, Error>) => Token;
  <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
    options: {
      readonly executionId: string;
      readonly workflow: Workflow.Any;
    },
  ): Token;
};

declare const tokenFromPayload: {
  <W extends Any>(options: {
    readonly payload: Schema.Simplify<Schema.Struct.Constructor<W["payloadSchema"]["fields"]>>;
    readonly workflow: W;
  }): <Success extends Any, Error extends All>(
    self: DurableDeferred<Success, Error>,
  ) => Effect<Token>;
  <Success extends Any, Error extends All, W extends Any>(
    self: DurableDeferred<Success, Error>,
    options: {
      readonly payload: Schema.Simplify<Schema.Struct.Constructor<W["payloadSchema"]["fields"]>>;
      readonly workflow: W;
    },
  ): Effect<Token>;
};

declare class TokenParsed extends ReadonlySide<
  {
    readonly deferredName: String;
    readonly executionId: String;
    readonly workflowName: String;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly deferredName: String;
        readonly executionId: String;
        readonly workflowName: String;
      }>,
      options?: MakeOptions,
    ]
  );
  static readonly encode: (input: any, options?: ParseOptions) => any;
  static readonly fromString: (input: any, options?: ParseOptions) => any;
  static readonly FromString: any;
  asToken: Token;
}

declare const TokenTypeId: unique symbol;

type TokenTypeId = typeof TokenTypeId;