export declare const effect: <Req extends Schema.TaggedRequest.Any, SR, I, R>(
  schema: Schema.Schema<Req, I, SR>,
  handler: (request: Req) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>
) => Rpc<Req, R>

export declare const stream: <Req extends StreamRequest.Any, I, SR, R>(
  schema: Schema.Schema<Req, I, SR>,
  handler: (
    request: Req
  ) => Stream.Stream<
    Req extends Serializable.WithResult<infer A, infer _I, infer _E, infer _EI, infer _R> ? A : never,
    Req extends Serializable.WithResult<infer _A, infer _I, infer E, infer _EI, infer _R> ? E : never,
    R
  >
) => Rpc<Req, R>

export declare const provideService: {
  <I, S>(
    tag: Context.Tag<I, S>,
    service: S
  ): <Req extends Schema.TaggedRequest.Any, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I>>
  <Req extends Schema.TaggedRequest.Any, R, I, S>(
    self: Rpc<Req, R>,
    tag: Context.Tag<I, S>,
    service: S
  ): Rpc<Req, Exclude<R, I>>
}

export declare const provideServiceEffect: {
  <I, S, E, R2>(
    tag: Context.Tag<I, S>,
    effect: Effect.Effect<S, E, R2>
  ): <Req extends Schema.TaggedRequest.Any, R>(self: Rpc<Req, R>) => Rpc<Req, R2 | Exclude<R, I>>
  <Req extends Schema.TaggedRequest.Any, R, I, S, E, R2>(
    self: Rpc<Req, R>,
    tag: Context.Tag<I, S>,
    effect: Effect.Effect<S, E, R2>
  ): Rpc<Req, R2 | Exclude<R, I>>
}

export declare const annotateHeaders: {
  (headers: Headers.Input): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(self: Effect.Effect<A, E, R>, headers: Headers.Input): Effect.Effect<A, E, R>
}

export declare const currentHeaders: FiberRef.FiberRef<Headers.Headers>

export declare const schemaHeaders: <R, I extends Record.ReadonlyRecord<string, string | undefined>, A>(
  schema: Schema.Schema<R, I, A>
) => Effect.Effect<R, ParseResult.ParseError, A>

export interface Request<A extends Schema.TaggedRequest.Any>
  extends EffectRequest.Request<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>>,
    PrimaryKey.PrimaryKey,
    Serializable.WithResult<
      Serializable.WithResult.Context<A>,
      Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["Failure"]>,
      Schema.Schema.Type<A[typeof Serializable.symbolResult]["Failure"]>,
      Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["Success"]>,
      Schema.Schema.Type<A[typeof Serializable.symbolResult]["Success"]>
    > {
  readonly request: A
  readonly traceId: string
  readonly spanId: string
  readonly sampled: boolean
  readonly headers: Headers.Headers
}

export interface RequestFrom<A> {
  readonly request: A
  readonly traceId: string
  readonly spanId: string
  readonly sampled: boolean
  readonly headers: Record<string, string>
}

export type Rpc<Req extends Schema.TaggedRequest.Any, R> = RpcEffect<Req, R> | RpcStream<Req, R>

export interface Proto<Req extends Schema.TaggedRequest.Any> extends Pipeable {
  readonly [TypeId]: TypeId
  readonly _tag: string
  readonly schema: Schema.Schema<Req, unknown, any>
}

export type Context<A extends Rpc<any, any>> =
  A extends Rpc<infer Req, infer R> ? R | Serializable.SerializableWithResult.Context<Req> : never

export type Request<A extends Rpc<any, any>> = Schema.Schema.Type<A["schema"]>

export type Result<A extends Schema.TaggedRequest.Any, R = never> =
  EffectRequest.Request.Success<A> extends Stream.Stream<infer A, infer E, infer _R>
    ? Stream.Stream<A, E, R>
    : Effect.Effect<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>, R>

export type ResultUndecoded<A extends Schema.TaggedRequest.Any, R = never> =
  A extends Serializable.WithResult<infer _A, infer I, infer _E, infer _EI, infer _R>
    ? EffectRequest.Request.Success<A> extends Stream.Stream<infer _A, infer E, infer _R>
      ? Stream.Stream<I, E, R>
      : Effect.Effect<I, EffectRequest.Request.Error<A>, R>
    : never

export interface RpcEffect<Req extends Schema.TaggedRequest.Any, R> extends Rpc.Proto<Req> {
  readonly _tag: "Effect"
  readonly handler: (
    request: Req
  ) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>
}

export interface RpcStream<Req extends Schema.TaggedRequest.Any, R> extends Rpc.Proto<Req> {
  readonly _tag: "Stream"
  readonly handler: (
    request: Req
  ) => Stream.Stream<
    Req extends Serializable.WithResult<infer A, infer _I, infer _E, infer _EI, infer _R> ? A : never,
    Req extends Serializable.WithResult<infer _A, infer _I, infer E, infer _EI, infer _R> ? E : never,
    R
  >
}

export declare const isRpc: (u: unknown) => u is Rpc<any, any>

export declare const call: <A extends Schema.TaggedRequest.Any, R extends unknown>(
  req: A,
  resolver: R,
  options?: { readonly spanPrefix?: string }
) => R extends Effect.Effect<infer _A, infer _E, infer R> ? Stream.Stream<A, E, R> : Stream.Stream<A, E, R>

export declare const request: <A extends Schema.TaggedRequest.Any>(
  request: A,
  options?: { readonly spanPrefix?: string }
) => Effect.Effect<Request<A>, never, Scope>

export declare const RequestSchema: <A, I, R>(
  schema: Schema.Schema<A, I, R>
) => Schema.Schema<RequestFrom<A>, RequestFrom<I>, R>

export declare const StreamRequest: <Self>() => <
  Tag extends string,
  E,
  IE,
  RE,
  A,
  IA,
  RA,
  Fields extends Schema.Struct.Fields
>(
  tag: Tag,
  failure: Schema.Schema<E, IE, RE>,
  success: Schema.Schema<A, IA, RA>,
  fields: Fields
) => StreamRequestConstructor<
  Tag,
  Self,
  Schema.Schema.Context<Fields[keyof Fields]>,
  Types.Simplify<Schema.Struct.Encoded<Fields>>,
  Types.Simplify<Schema.Struct.Type<Fields>>,
  RE | RA,
  IE,
  E,
  IA,
  A
>

export interface StreamRequest<Tag extends string, SR, SI, S, RR, EI, E, AI, A>
  extends EffectRequest.Request<Stream.Stream<A, E, never>>,
    Serializable.SerializableWithResult<S, SI, SR, A, AI, E, EI, RR> {
  readonly _tag: Tag
}

export type Any =
  | StreamRequest<string, any, any, any, any, any, any, any, any>
  | StreamRequest<string, any, any, any, any, never, never, any, any>

export interface StreamRequestConstructor<Tag extends string, Self, R, IS, S, RR, IE, E, IA, A>
  extends Schema.Schema<Self, Types.Simplify<IS & { readonly _tag: Tag }>, R> {
  new (
    props: Types.Equals<S, {}> extends true ? void : S,
    disableValidation?: boolean
  ): StreamRequest<Tag, R, IS & { readonly _tag: Tag }, Self, RR, IE, E, IA, A> & S
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId