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

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

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

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

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

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

export interface Any {
  readonly [TypeId]: TypeId
  readonly name: string
  readonly successSchema: Schema.Schema.Any
  readonly errorSchema: Schema.Schema.All
  readonly exitSchema: Schema.Exit<any, any, any>
}

export interface DurableDeferred<
  Success extends Schema.Schema.Any,
  Error extends Schema.Schema.All = typeof Schema.Never
> {
  readonly [TypeId]: TypeId
  readonly name: string
  readonly successSchema: Success
  readonly errorSchema: Error
  readonly exitSchema: Schema.Exit<Success, Error, typeof Schema.Defect>
}

declare const raceAll: <
  const Effects extends NonEmptyReadonlyArray<Effect.Effect<any, any, any>>,
  SI,
  SR,
  EI,
  ER
>(options: {
  name: string
  success: Schema.Schema<Effects[number] extends Effect.Effect<infer S, infer _E, infer _R> ? S : never, SI, SR>
  error: Schema.Schema<Effects[number] extends Effect.Effect<infer _S, infer E, infer _R> ? E : never, EI, ER>
  effects: Effects
}) => Effect.Effect<
  Effects[number] extends Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
  Effects[number] extends Effect.Effect<infer _A, infer _E, infer _R> ? _E : never,
  | (Effects[number] extends Effect.Effect<infer _A, infer _R, infer R> ? R : never)
  | SR
  | ER
  | WorkflowEngine
  | WorkflowInstance
>

declare const TypeId: unique symbol

type TypeId = typeof TypeId

declare const Token: Schema.brand<typeof Schema.String, unique symbol>

type Token = Brand.Branded<string, TokenTypeId>

declare class TokenParsed

declare const TokenTypeId: unique symbol

type TokenTypeId = typeof TokenTypeId

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

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

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