export declare const getFailure: <A, E, R>(ref: RefAsyncData<A, E, R>) => RefSubject.Filtered<E, never, R>

export declare const getSuccess: <A, E, R>(ref: RefAsyncData<A, E, R>) => RefSubject.Filtered<A, never, R>

export declare const asSink: <A, E, R>(ref: RefAsyncData<A, E, R>) => Sink.Sink<A, E, R>

export declare const awaitLoading: <A, E, R>(
  data: RefAsyncData<A, E, R>
) => Effect.Effect<
  AsyncData.NoData | AsyncData.Failure<E> | AsyncData.Success<A> | AsyncData.Optimistic<A, E>,
  never,
  Scope.Scope | R
>

export declare const awaitLoadingOrRefreshing: <A, E, R>(
  data: RefAsyncData<A, E, R>
) => Effect.Effect<
  AsyncData.NoData | AsyncData.Failure<E> | AsyncData.Success<A> | AsyncData.Optimistic<A, E>,
  never,
  Scope.Scope | R
>

export declare const startLoading: <A, E, R>(
  ref: RefAsyncData<A, E, R>
) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>

export declare const stopLoading: <A, E, R>(
  ref: RefAsyncData<A, E, R>
) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>

export interface RefAsyncData<A, E = never, R = never>
  extends RefSubject.RefSubject<AsyncData.AsyncData<A, E>, never, R> {}

export declare function asyncDataRequest<A, E, R>(
  effect: Effect.Effect<A, E, R>
): Fx.Fx<AsyncData.AsyncData<A, E>, never, R>

export declare const done: {
  <E, A>(exit: Exit.Exit<A, E>): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
  <A, E, R>(ref: RefAsyncData<A, E, R>, exit: Exit.Exit<A, E>): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
}

export declare const fail: {
  <E>(
    error: E,
    options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
  ): <R, A>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
  <A, E, R>(
    ref: RefAsyncData<A, E, R>,
    error: E,
    options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
}

export declare const failCause: {
  <E>(
    cause: Cause.Cause<E>,
    options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
  ): <R, A>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
  <A, E, R>(
    ref: RefAsyncData<A, E, R>,
    cause: Cause.Cause<E>,
    options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
}

export declare const isSuccess: <A, E, R>(ref: RefAsyncData<A, E, R>) => RefSubject.Computed<boolean, never, R>

export declare const mapInput: <A, E, R, B>(ref: RefAsyncData<A, E, R>, f: (b: B) => A) => Sink.Sink<B, E, R>

export declare const mapInputEffect: <A, E, R, R2, B>(
  ref: RefAsyncData<A, E, R>,
  f: (b: B) => Effect.Effect<A, E, R2>
) => Sink.Sink<B, E, R | R2>

export declare const matchAsyncData: {
  <E1, A, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(matchers: {
    readonly NoData: Fx.Fx<B, E2, R2>
    readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
    readonly Failure: (error: RefSubject.Computed<E1, never, never>) => Fx.Fx<D, E4, R4>
    readonly Success: (value: RefSubject.RefSubject<A, never, never>) => Fx.Fx<F, E5, R5>
  }): <E, R>(
    fx: Fx.Fx<AsyncData.AsyncData<A, E1>, E, R>
  ) => Fx.Fx<B | C | D | F, E2 | E3 | E4 | E5 | E, R2 | R3 | R4 | R5 | R>
  <R, E, E1, A, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
    fx: Fx.Fx<AsyncData.AsyncData<A, E1>, E, R>,
    matchers: {
      readonly NoData: Fx.Fx<B, E2, R2>
      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
      readonly Failure: (error: RefSubject.Computed<E1, never, never>) => Fx.Fx<D, E4, R4>
      readonly Success: (value: RefSubject.RefSubject<A, never, never>) => Fx.Fx<F, E5, R5>
    }
  ): Fx.Fx<B | C | D | F, E | E2 | E3 | E4 | E5, R | R2 | R3 | R4 | R5>
}

export declare const matchAsyncDataArray: {
  <E1, A, K extends PropertyKey, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
    getKey: (a: A) => K,
    matchers: {
      readonly NoData: Fx.Fx<B, E2, R2>
      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
      readonly Failure: (error: RefSubject.Computed<E1, never, never>) => Fx.Fx<D, E4, R4>
      readonly Success: (value: RefSubject.RefSubject<A, never, never>, key: K) => Fx.Fx<F, E5, R5>
    }
  ): <E, R>(
    fx: Fx.Fx<AsyncData.AsyncData<readonly A[], E1>, E, R>
  ) => Fx.Fx<B | C | D | readonly F[], E2 | E3 | E4 | E5 | E, Scope.Scope | R2 | R3 | R4 | R5 | R>
  <R, E, E1, A, K extends PropertyKey, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
    fx: Fx.Fx<AsyncData.AsyncData<readonly A[], E1>, E, R>,
    getKey: (a: A) => K,
    matchers: {
      readonly NoData: Fx.Fx<B, E2, R2>
      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
      readonly Failure: (error: RefSubject.Computed<E1, never, never>) => Fx.Fx<D, E4, R4>
      readonly Success: (value: RefSubject.RefSubject<A, never, never>, key: K) => Fx.Fx<F, E5, R5>
    }
  ): Fx.Fx<B | C | D | readonly F[], E | E2 | E3 | E4 | E5, Scope.Scope | R | R2 | R3 | R4 | R5>
}

export declare const optimistic: {
  <A>(
    value: A,
    options?: AsyncData.OptionalPartial<AsyncData.OptimisticOptions>
  ): <E, R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
  <A, E, R>(
    ref: RefAsyncData<A, E, R>,
    value: A,
    options?: AsyncData.OptionalPartial<AsyncData.OptimisticOptions>
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
}

export declare const runAsyncData: {
  <R2, A, E>(
    effect: Effect.Effect<A, E, R2>
  ): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R2 | R>
  <A, E, R, R2>(
    ref: RefAsyncData<A, E, R>,
    effect: Effect.Effect<A, E, R2>
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
}

export declare const runIfExpired: {
  <R2, A, E>(
    effect: Effect.Effect<A, E, R2>,
    options: { readonly ttl: Duration.DurationInput; readonly now?: number }
  ): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R2 | R>
  <A, E, R, R2>(
    ref: RefAsyncData<A, E, R>,
    effect: Effect.Effect<A, E, R2>,
    options: { readonly ttl: Duration.DurationInput; readonly now?: number }
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
}

export declare const runIfNoData: {
  <R2, A, E>(
    effect: Effect.Effect<A, E, R2>
  ): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R2 | R>
  <A, E, R, R2>(
    ref: RefAsyncData<A, E, R>,
    effect: Effect.Effect<A, E, R2>
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
}

export declare const succeed: {
  <A>(
    value: A,
    options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
  ): <E, R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
  <A, E, R>(
    ref: RefAsyncData<A, E, R>,
    value: A,
    options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
}