export declare const fetch: Client.Default

export declare const fetchOk: Client.Default

export declare const make: <A, E, R, R2, E2>(
  execute: (request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>) => Effect.Effect<A, E, R>,
  preprocess: Client.Preprocess<E2, R2>
) => Client<A, E, R>

export declare const makeDefault: (
  f: (
    request: ClientRequest.ClientRequest,
    url: URL,
    signal: AbortSignal,
    fiber: RuntimeFiber<ClientResponse.ClientResponse, Error.HttpClientError>
  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError, Scope.Scope>
) => Client.Default

export declare const withCookiesRef: {
  (ref: Ref<Cookies>): <E, R>(self: Client.WithResponse<E, R>) => Client.WithResponse<E, R>
  <E, R>(self: Client.WithResponse<E, R>, ref: Ref<Cookies>): Client.WithResponse<E, R>
}

export declare const catchAll: {
  <E, R2, E2, A2>(f: (e: E) => Effect.Effect<A2, E2, R2>): <A, R>(self: Client<A, E, R>) => Client<A2 | A, E2, R2 | R>
  <A, E, R, R2, E2, A2>(self: Client<A, E, R>, f: (e: E) => Effect.Effect<A2, E2, R2>): Client<A | A2, E2, R | R2>
}

export declare const catchTag: {
  <E extends { _tag: string }, K extends E["_tag"] & string, R1, E1, A1>(
    tag: K,
    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
  ): <A, R>(self: Client<A, E, R>) => Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
  <R, E extends { _tag: string }, A, K extends E["_tag"] & string, E1, R1, A1>(
    self: Client<A, E, R>,
    tag: K,
    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
  ): Client<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1>
}

export declare const catchTags: {
  <
    E extends { _tag: string },
    Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) | undefined }
  >(
    cases: Cases
  ): <A, R>(
    self: Client<A, E, R>
  ) => Client<
    | A
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : never
      }[keyof Cases],
    | Exclude<E, { _tag: keyof Cases }>
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
      }[keyof Cases],
    | R
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
      }[keyof Cases]
  >
  <
    A,
    E extends { _tag: string },
    R,
    Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) | undefined }
  >(
    self: Client<A, E, R>,
    cases: Cases
  ): Client<
    | A
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : never
      }[keyof Cases],
    | Exclude<E, { _tag: keyof Cases }>
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
      }[keyof Cases],
    | R
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
      }[keyof Cases]
  >
}

export declare const retry: {
  <B, E extends E0, E0, R1>(policy: Schedule.Schedule<B, E0, R1>): <A, R>(self: Client<A, E, R>) => Client<A, E, R1 | R>
  <A, E extends E0, E0, R, R1, B>(self: Client<A, E, R>, policy: Schedule.Schedule<B, E0, R1>): Client<A, E, R | R1>
}

export declare const currentFetchOptions: FiberRef.FiberRef<RequestInit>

export declare const currentTracerDisabledWhen: FiberRef.FiberRef<Predicate.Predicate<ClientRequest.ClientRequest>>

export declare const withFetchOptions: {
  (options: RequestInit): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <R, E, A>(effect: Effect.Effect<A, E, R>, options: RequestInit): Effect.Effect<A, E, R>
}

export declare const withTracerDisabledWhen: {
  (
    predicate: Predicate.Predicate<ClientRequest.ClientRequest>
  ): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <R, E, A>(
    effect: Effect.Effect<A, E, R>,
    predicate: Predicate.Predicate<ClientRequest.ClientRequest>
  ): Effect.Effect<A, E, R>
}

export declare const filterOrElse: {
  <A, R2, E2, B>(
    f: Predicate.Predicate<A>,
    orElse: (a: A) => Effect.Effect<B, E2, R2>
  ): <E, R>(self: Client<A, E, R>) => Client<A | B, E2 | E, R2 | R>
  <A, E, R, R2, E2, B>(
    self: Client<A, E, R>,
    f: Predicate.Predicate<A>,
    orElse: (a: A) => Effect.Effect<B, E2, R2>
  ): Client<A | B, E | E2, R | R2>
}

export declare const filterOrFail: {
  <A, E2>(f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): <E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R>
  <A, E, R, E2>(self: Client<A, E, R>, f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): Client<A, E | E2, R>
}

export declare const filterStatus: {
  (
    f: (status: number) => boolean
  ): <E, R>(self: Client.WithResponse<E, R>) => Client.WithResponse<Error.ResponseError | E, R>
  <E, R>(
    self: Client.WithResponse<E, R>,
    f: (status: number) => boolean
  ): Client.WithResponse<Error.ResponseError | E, R>
}

export declare const filterStatusOk: <E, R>(
  self: Client.WithResponse<E, R>
) => Client.WithResponse<Error.ResponseError | E, R>

export declare const layer: Layer.Layer<Client.Default>

export declare const map: {
  <A, B>(f: (a: A) => B): <E, R>(self: Client<A, E, R>) => Client<B, E, R>
  <A, E, R, B>(self: Client<A, E, R>, f: (a: A) => B): Client<B, E, R>
}

export declare const mapEffect: {
  <A, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(self: Client<A, E, R>) => Client<B, E2 | E, R2 | R>
  <A, E, R, R2, E2, B>(self: Client<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Client<B, E | E2, R | R2>
}

export declare const mapEffectScoped: {
  <A, R2, E2, B>(
    f: (a: A) => Effect.Effect<B, E2, R2>
  ): <E, R>(self: Client<A, E, R>) => Client<B, E2 | E, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
  <A, E, R, R2, E2, B>(
    self: Client<A, E, R>,
    f: (a: A) => Effect.Effect<B, E2, R2>
  ): Client<B, E | E2, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
}

export declare const mapInputRequest: {
  (
    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E, R>
  <A, E, R>(self: Client<A, E, R>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<A, E, R>
}

export declare const mapInputRequestEffect: {
  <R2, E2>(
    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
  <A, E, R, R2, E2>(
    self: Client<A, E, R>,
    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
  ): Client<A, E | E2, R | R2>
}

export declare const mapRequest: {
  (
    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E, R>
  <A, E, R>(self: Client<A, E, R>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<A, E, R>
}

export declare const mapRequestEffect: {
  <R2, E2>(
    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
  <A, E, R, R2, E2>(
    self: Client<A, E, R>,
    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
  ): Client<A, E | E2, R | R2>
}

export declare const tap: {
  <A, R2, E2, _>(f: (a: A) => Effect.Effect<_, E2, R2>): <E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
  <A, E, R, R2, E2, _>(self: Client<A, E, R>, f: (a: A) => Effect.Effect<_, E2, R2>): Client<A, E | E2, R | R2>
}

export declare const tapRequest: {
  <R2, E2, _>(
    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
  <A, E, R, R2, E2, _>(
    self: Client<A, E, R>,
    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
  ): Client<A, E | E2, R | R2>
}

export declare const transform: {
  <A, E, R, R1, E1, A1>(
    f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
  ): (self: Client<A, E, R>) => Client<A1, E | E1, R | R1>
  <A, E, R, R1, E1, A1>(
    self: Client<A, E, R>,
    f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
  ): Client<A1, E | E1, R | R1>
}

export declare const transformResponse: {
  <A, E, R, R1, E1, A1>(
    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
  ): (self: Client<A, E, R>) => Client<A1, E1, R1>
  <A, E, R, R1, E1, A1>(
    self: Client<A, E, R>,
    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
  ): Client<A1, E1, R1>
}

export interface Client<A = ClientResponse.ClientResponse, E = never, R = never> extends Pipeable, Inspectable {
  (request: ClientRequest.ClientRequest): Effect.Effect<A, E, R>
  readonly [TypeId]: TypeId
  readonly preprocess: Client.Preprocess<E, R>
  readonly execute: Client.Execute<A, E, R>
}

export interface Fetch {
  readonly _: unique symbol
}

export declare const scoped: <A, E, R>(self: Client<A, E, R>) => Client<A, E, Exclude<R, Scope.Scope>>

export declare const schemaFunction: {
  <SA, SI, SR>(
    schema: Schema.Schema<SA, SI, SR>,
    options?: ParseOptions | undefined
  ): <A, E, R>(
    self: Client<A, E, R>
  ) => (request: ClientRequest.ClientRequest) => (a: SA) => Effect.Effect<A, any, SR | R>
  <A, E, R, SA, SI, SR>(
    self: Client<A, E, R>,
    schema: Schema.Schema<SA, SI, SR>,
    options?: ParseOptions | undefined
  ): (request: ClientRequest.ClientRequest) => (a: SA) => Effect.Effect<A, any, R | SR>
}

export declare const Client: Context.Tag<Client.Default, Client.Default>

export declare const Fetch: Context.Tag<Fetch, typeof globalThis.fetch>

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

export type Default = WithResponse<Error.HttpClientError, Scope.Scope>

export type Execute<A, E = never, R = never> = (
  request: Effect.Effect<ClientRequest.ClientRequest, E, R>
) => Effect.Effect<A, E, R>

export type Preprocess<E, R> = (
  request: ClientRequest.ClientRequest
) => Effect.Effect<ClientRequest.ClientRequest, E, R>

export type WithResponse<E = never, R = never> = Client<ClientResponse.ClientResponse, E, R>