export interface AiPlan<in Error, in out Provides, in out Requires>
  extends Pipeable,
    AiPlan.Builder<Provides, Requires> {
  readonly [TypeId]: TypeId
  readonly [Unify.typeSymbol]?: unknown
  readonly [Unify.unifySymbol]?: AiPlanUnify<this>
  readonly [Unify.ignoreSymbol]?: AiPlanUnifyIgnore
  readonly steps: NonEmptyReadonlyArray<AiPlan.Step<Error, Provides, Requires>>
}

export interface AiPlanUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
  AiPlan?: () => Extract<A[Unify.typeSymbol], AiPlan<any, any, any>>
}

export interface AiPlanUnifyIgnore extends Effect.EffectUnifyIgnore {
  Effect?: true
}

declare const concatSteps: {
  <Error2, Provides2, Requires2>(
    other: AiPlan<Error2, Provides2, Requires2>
  ): <Error, Provides, Requires>(
    self: AiPlan<Error, Provides, Requires>
  ) => AiPlan<Error & Error2, Provides & Provides2, Requires | Requires2>
  <Error, Provides, Requires, Error2, Provides2, Requires2>(
    self: AiPlan<Error, Provides, Requires>,
    other: AiPlan<Error2, Provides2, Requires2>
  ): AiPlan<Error & Error2, Provides & Provides2, Requires | Requires2>
}

declare const fromModel: <Provides, Requires, EW, Out, ES, RW = never, RS = never>(
  model: AiModel.AiModel<Provides, Requires>,
  options?: {
    readonly attempts?: number | undefined
    readonly while?: ((error: EW) => boolean | Effect.Effect<boolean, never, RW>) | undefined
    readonly schedule?: Schedule.Schedule<Out, ES, RS> | undefined
  }
) => AiPlan<EW & ES, Provides, RW | RS | Requires>

declare const withFallback: {
  <Provides, Provides2 extends Provides, Requires2, Out, EW, ES, RW = never, RS = never>(options: {
    readonly model: AiModel.AiModel<Provides2, Requires2>
    readonly attempts?: number | undefined
    readonly while?: ((error: EW) => boolean | Effect.Effect<boolean, never, RW>) | undefined
    readonly schedule?: Schedule.Schedule<Out, ES, RS> | undefined
  }): <E, Requires>(
    self: AiPlan<E, Provides, Requires>
  ) => AiPlan<E & EW & ES, Provides & Provides2, Requires | Requires2 | RW | RS>
  <E, Provides, Requires, Provides2 extends Provides, Requires2, Out, EW, ES, RW = never, RS = never>(
    self: AiPlan<E, Provides, Requires>,
    options: {
      readonly model: AiModel.AiModel<Provides2, Requires2>
      readonly attempts?: number | undefined
      readonly while?: ((error: EW) => boolean | Effect.Effect<boolean, never, RW>) | undefined
      readonly schedule?: Schedule.Schedule<Out, ES, RS> | undefined
    }
  ): AiPlan<E & EW & ES, Provides & Provides2, Requires | Requires2 | RW | RS>
}

declare const TypeId: unique symbol

type TypeId = typeof TypeId

export interface Provider<Provides> {
  readonly provide: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Provides>>
}

export interface Step<Error, Provides, Requires> {
  readonly model: AiModel.AiModel<Provides, Requires>
  readonly check: Option.Option<(error: Error) => boolean | Effect.Effect<boolean>>
  readonly schedule: Option.Option<Schedule.Schedule<any, Error, Requires>>
}

type Effect.Effect<Provider<Provides>, never, AiModels | Requires> = Effect.Effect<Provider<Provides>, never, AiModels | Requires>