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$ {
  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$ {
  readonly _: typeof _;
}

declare function Empty(status: number): Void;

declare const NoContent: NoContent;

interface NoContent extends Void$ {
  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;