import * as Effect from "../../Effect.ts";
import * as ErrorReporter from "../../ErrorReporter.ts";
import * as Schema from "../../Schema.ts";
import * as HttpServerRespondable from "../http/HttpServerRespondable.ts";
import * as HttpServerResponse from "../http/HttpServerResponse.ts";
import * as HttpApiSchema from "./HttpApiSchema.ts";
declare const BadRequest_base: Schema.Class<BadRequest, Schema.Struct<{
    readonly _tag: Schema.tag<"BadRequest">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class BadRequest extends BadRequest_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
    static readonly singleton: BadRequest;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const BadRequestNoContent: HttpApiSchema.asNoContent<typeof BadRequest>;
declare const Unauthorized_base: Schema.Class<Unauthorized, Schema.Struct<{
    readonly _tag: Schema.tag<"Unauthorized">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class Unauthorized extends Unauthorized_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const UnauthorizedNoContent: HttpApiSchema.asNoContent<typeof Unauthorized>;
declare const Forbidden_base: Schema.Class<Forbidden, Schema.Struct<{
    readonly _tag: Schema.tag<"Forbidden">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class Forbidden extends Forbidden_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const ForbiddenNoContent: HttpApiSchema.asNoContent<typeof Forbidden>;
declare const NotFound_base: Schema.Class<NotFound, Schema.Struct<{
    readonly _tag: Schema.tag<"NotFound">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class NotFound extends NotFound_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const NotFoundNoContent: HttpApiSchema.asNoContent<typeof NotFound>;
declare const MethodNotAllowed_base: Schema.Class<MethodNotAllowed, Schema.Struct<{
    readonly _tag: Schema.tag<"MethodNotAllowed">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class MethodNotAllowed extends MethodNotAllowed_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const MethodNotAllowedNoContent: HttpApiSchema.asNoContent<typeof MethodNotAllowed>;
declare const NotAcceptable_base: Schema.Class<NotAcceptable, Schema.Struct<{
    readonly _tag: Schema.tag<"NotAcceptable">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class NotAcceptable extends NotAcceptable_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const NotAcceptableNoContent: HttpApiSchema.asNoContent<typeof NotAcceptable>;
declare const RequestTimeout_base: Schema.Class<RequestTimeout, Schema.Struct<{
    readonly _tag: Schema.tag<"RequestTimeout">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class RequestTimeout extends RequestTimeout_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const RequestTimeoutNoContent: HttpApiSchema.asNoContent<typeof RequestTimeout>;
declare const Conflict_base: Schema.Class<Conflict, Schema.Struct<{
    readonly _tag: Schema.tag<"Conflict">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class Conflict extends Conflict_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @since 4.0.0
 * @category NoContent errors
 */
export declare const ConflictNoContent: HttpApiSchema.asNoContent<typeof Conflict>;
declare const Gone_base: Schema.Class<Gone, Schema.Struct<{
    readonly _tag: Schema.tag<"Gone">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class Gone extends Gone_base {
    readonly [ErrorReporter.ignore] = true;
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const GoneNoContent: HttpApiSchema.asNoContent<typeof Gone>;
declare const InternalServerError_base: Schema.Class<InternalServerError, Schema.Struct<{
    readonly _tag: Schema.tag<"InternalServerError">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class InternalServerError extends InternalServerError_base {
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const InternalServerErrorNoContent: HttpApiSchema.asNoContent<typeof InternalServerError>;
declare const NotImplemented_base: Schema.Class<NotImplemented, Schema.Struct<{
    readonly _tag: Schema.tag<"NotImplemented">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class NotImplemented extends NotImplemented_base {
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const NotImplementedNoContent: HttpApiSchema.asNoContent<typeof NotImplemented>;
declare const ServiceUnavailable_base: Schema.Class<ServiceUnavailable, Schema.Struct<{
    readonly _tag: Schema.tag<"ServiceUnavailable">;
}>, import("../../Cause.ts").YieldableError>;
/**
 * @category Built-in errors
 * @since 4.0.0
 */
export declare class ServiceUnavailable extends ServiceUnavailable_base {
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
/**
 * @category NoContent errors
 * @since 4.0.0
 */
export declare const ServiceUnavailableNoContent: HttpApiSchema.asNoContent<typeof ServiceUnavailable>;
/**
 * @category Parsing errors
 * @since 4.0.0
 */
export type HttpApiSchemaErrorTypeId = "~effect/httpapi/HttpApiError/HttpApiSchemaError";
/**
 * @category Parsing errors
 * @since 4.0.0
 */
export declare const HttpApiSchemaErrorTypeId: HttpApiSchemaErrorTypeId;
declare const HttpApiSchemaError_base: new <A extends Record<string, any> = {}>(args: import("../../Types.ts").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "HttpApiSchemaError";
} & import("../../Pipeable.ts").Pipeable;
/**
 * @category Parsing errors
 * @since 4.0.0
 */
export declare class HttpApiSchemaError extends HttpApiSchemaError_base<{
    readonly kind: "Params" | "Headers" | "Query" | "Body" | "Payload";
    readonly cause: Schema.SchemaError;
}> {
    readonly [HttpApiSchemaErrorTypeId]: HttpApiSchemaErrorTypeId;
    static is(u: unknown): u is HttpApiSchemaError;
    static wrap<A, R>(kind: HttpApiSchemaError["kind"], effect: Effect.Effect<A, Schema.SchemaError, R>): Effect.Effect<A, HttpApiSchemaError, R>;
    readonly name = "HttpApiSchemaError";
    readonly message: "Headers" | "Params" | "Query" | "Body" | "Payload";
    [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
}
export {};
//# sourceMappingURL=HttpApiError.d.ts.map