export declare const AnnotationEmptyDecodeable: typeof AnnotationEmptyDecodeable

export declare const AnnotationEncoding: typeof AnnotationEncoding

export declare const AnnotationMultipart: typeof AnnotationMultipart

export declare const AnnotationParam: typeof AnnotationParam

export declare const AnnotationStatus: typeof AnnotationStatus

export declare const annotations: <A>(
  annotations: Schema.Annotations.Schema<NoInfer<A>> & { readonly status?: number | undefined }
) => Schema.Annotations.Schema<A>

export declare const extractAnnotations: (ast: AST.Annotations) => AST.Annotations

export declare const getEmptyDecodeable: (ast: AST.AST) => boolean

export declare const getEncoding: (ast: AST.AST) => Encoding

export declare const getMultipart: (ast: AST.AST) => boolean

export declare const getParam: (ast: AST.AST) => string | undefined

export declare const getStatus: (ast: AST.AST, defaultStatus: number) => number

export declare const EmptyError: <Self>() => <const Tag extends string>(options: {
  readonly tag: Tag
  readonly status: number
}) => EmptyErrorClass<Self, Tag>

export interface EmptyErrorClass<Self, Tag> extends Schema.Schema<Self, void> {
  new (_: void): { readonly _tag: Tag } & Effect.Effect<never, Self>
}

export declare const Accepted: Accepted

export interface Accepted extends Void$ {
  readonly _: unique symbol
}

export declare const Created: Created

export interface Created extends Void$ {
  readonly _: unique symbol
}

export declare const Empty: (status: number) => typeof Schema.Void

export declare const NoContent: NoContent

export interface NoContent extends Void$ {
  readonly _: unique symbol
}

export declare const asEmpty: {
  <S extends Schema.Schema.Any>(options: {
    readonly status: number
    readonly decode: LazyArg<Schema.Schema.Type<S>>
  }): (self: S) => asEmpty<S>
  <S extends Schema.Schema.Any>(
    self: S,
    options: { readonly status: number; readonly decode: LazyArg<Schema.Schema.Type<S>> }
  ): asEmpty<S>
}

export interface asEmpty<S extends Schema.Schema.Any> extends Schema.transform<typeof Schema.Void, S> {}

export interface Encoding {
  readonly kind: "Json" | "UrlParams" | "Uint8Array" | "Text"
  readonly contentType: string
}

export type Validate<A extends Schema.Schema.Any, Kind extends Encoding["kind"]> = Kind extends "Json"
  ? {}
  : Kind extends "UrlParams"
    ? [A["Encoded"]] extends [Readonly<Record<string, string | undefined>>]
      ? {}
      : `'UrlParams' kind can only be encoded to 'Record<string, string | undefined>'`
    : Kind extends "Uint8Array"
      ? [A["Encoded"]] extends [Uint8Array]
        ? {}
        : `'Uint8Array' kind can only be encoded to 'Uint8Array'`
      : Kind extends "Text"
        ? [A["Encoded"]] extends [string]
          ? {}
          : `'Text' kind can only be encoded to 'string'`
        : never

export declare const Text: (options?: { readonly contentType?: string }) => typeof Schema.String

export declare const Uint8Array: (options?: { readonly contentType?: string }) => typeof Schema.Uint8ArrayFromSelf

export declare const withEncoding: {
  <A extends Schema.Schema.Any, Kind extends Encoding["kind"]>(
    options: { readonly kind: Kind; readonly contentType?: string | undefined } & Encoding.Validate<A, Kind>
  ): (self: A) => A
  <A extends Schema.Schema.Any, Kind extends Encoding["kind"]>(
    self: A,
    options: { readonly kind: Kind; readonly contentType?: string | undefined } & Encoding.Validate<A, Kind>
  ): A
}

export declare const Multipart: <S extends Schema.Schema.Any>(self: S) => Multipart<S>

export interface Multipart<S extends Schema.Schema.Any>
  extends Schema.Schema<
    Schema.Schema.Type<S> & Brand<MultipartTypeId>,
    Schema.Schema.Encoded<S>,
    Schema.Schema.Context<S>
  > {}

export declare const MultipartTypeId: typeof MultipartTypeId

export type MultipartTypeId = typeof MultipartTypeId

export type AnyString = Schema.Schema<any, string, never> | Schema.Schema<any, string, any>

export interface Param<Name extends string, S extends Schema.Schema.Any>
  extends Schema.Schema<S["Type"], S["Encoded"], S["Context"]> {
  readonly [AnnotationParam]: Name
}

export declare const param: {
  <Name extends string>(name: Name): <S extends AnyString>(schema: S) => Param<Name, S>
  <Name extends string, S extends AnyString>(name: Name, schema: S): Param<Name, S>
}

export declare const getStatusError: <A extends Schema.Schema.All>(self: A) => number

export declare const getStatusErrorAST: (ast: AST.AST) => number

export declare const getStatusSuccess: <A extends Schema.Schema.Any>(self: A) => number

export declare const getStatusSuccessAST: (ast: AST.AST) => number

export declare const isVoid: (ast: AST.AST) => boolean

export declare const UnionUnify: <A extends Schema.Schema.All, B extends Schema.Schema.All>(
  self: A,
  that: B
) => Schema.Schema<A["Type"] | B["Type"], A["Encoded"] | B["Encoded"], A["Context"] | B["Context"]>

export declare const deunionize: (schemas: Set<Schema.Schema.Any>, schema: Schema.Schema.Any) => void