HttpApiSchema

declare const AnnotationEmptyDecodeable: unique symbol

declare const AnnotationEncoding: unique symbol

declare const AnnotationMultipart: unique symbol

declare const AnnotationMultipartStream: unique symbol

declare const AnnotationParam: unique symbol

declare function annotations<A>(annotations: any): Schema<A>

declare const AnnotationStatus: unique symbol

declare function extractAnnotations(ast: Annotations): Annotations

declare function getEmptyDecodeable(ast: AST): boolean

declare function getEncoding(ast: AST, fallback: Encoding): Encoding

declare function getMultipart(ast: AST): Options | undefined

declare function getMultipartStream(ast: AST): Options | undefined

declare function getParam(ast: any): string | undefined

declare function getStatus(ast: AST, defaultStatus: number): number

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

interface EmptyError<Self, Tag> extends Effect<never, Self> {
  readonly _tag: Tag;
  [ignoreSymbol]?: EmptyErrorUnifyIgnore;
  [typeSymbol]?: unknown;
  [unifySymbol]?: EmptyErrorUnify<EmptyError<Self, Tag>>;
}

interface EmptyErrorClass<Self, Tag> extends Schema<Self, void> {
  constructor(_: void);
}

declare const Accepted: Accepted

interface Accepted extends Void$ {
  constructor(_: never);
  readonly _: typeof _;
}

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

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

declare const Created: Created

interface Created extends Void$ {
  constructor(_: never);
  readonly _: typeof _;
}

declare function Empty(status: number): Void

declare const NoContent: NoContent

interface NoContent extends Void$ {
  constructor(_: never);
  readonly _: typeof _;
}

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

declare function Text(options?: {
  readonly contentType?: string;
}): String

declare function Uint8Array(options?: {
  readonly contentType?: string;
}): any

declare const withEncoding: {
  <A extends Any, Kind extends "Json" | "UrlParams" | "Uint8Array" | "Text">(options: {
    readonly contentType?: string;
    readonly kind: Kind;
  } & Validate<A, Kind>): (self: A) => A;
  <A extends Any, Kind extends "Json" | "UrlParams" | "Uint8Array" | "Text">(self: A, options: {
    readonly contentType?: string;
    readonly kind: Kind;
  } & Validate<A, Kind>): A;
}

interface EmptyErrorUnify<A extends {
  [typeSymbol]?: any;
}> extends EffectUnify<A> {
  EmptyError?: () => A[typeof typeSymbol] extends EmptyError<Self, _Tag> | _ ? Self : never;
}

interface EmptyErrorUnifyIgnore extends EffectUnifyIgnore {
  Effect?: true;
}

declare const Multipart: <S extends Any>(self: S, options?: {
  readonly fieldMimeTypes?: readonly Array<string>;
  readonly maxFieldSize?: SizeInput;
  readonly maxFileSize?: Option<SizeInput>;
  readonly maxParts?: Option<number>;
  readonly maxTotalSize?: Option<SizeInput>;
}) => Multipart<S>

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

declare const MultipartStream: <S extends Any>(self: S, options?: {
  readonly fieldMimeTypes?: readonly Array<string>;
  readonly maxFieldSize?: SizeInput;
  readonly maxFileSize?: Option<SizeInput>;
  readonly maxParts?: Option<number>;
  readonly maxTotalSize?: Option<SizeInput>;
}) => MultipartStream<S>

interface MultipartStream<S extends Schema.Schema.Any> extends Schema<Schema.Schema.Type<S> & Brand<MultipartStreamTypeId>, Schema.Schema.Encoded<S>, Schema.Schema.Context<S>> {}

declare const MultipartStreamTypeId: unique symbol

type MultipartStreamTypeId = typeof MultipartStreamTypeId

declare const MultipartTypeId: unique symbol

type MultipartTypeId = typeof MultipartTypeId

declare function deunionize(schemas: Set<Any>, schema: Any): void

declare function UnionUnify<A extends All, B extends All>(self: A, that: B): any

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

interface Param<Name extends string, S extends Schema.Schema.Any | Schema.PropertySignature.Any> extends Schema<Schema.Schema.Type<S>, Schema.Schema.Encoded<S>, Schema.Schema.Context<S>> {
  readonly [AnnotationParam]: {
    readonly name: Name;
    readonly schema: S;
  };
}

declare function getStatusError<A extends All>(self: A): number

declare function getStatusErrorAST(ast: AST): number

declare function getStatusSuccess<A extends Any>(self: A): number

declare function getStatusSuccessAST(ast: AST): number

declare function isVoid(ast: AST): boolean