@duplojs/http 0.2.0 → 0.4.0

package/dist/core/response/contract.d.ts

@@ -1,284 +1,286 @@
 import { DP, type Kind, type NeverCoalescing } from "@duplojs/utils";
-import { type ResponseCode, type Response } from ".";
+import { type ResponseCode, type PredictedResponse } from ".";
+import { type ForbiddenBigintDataParser } from "../types";
 export declare namespace ResponseContract {
+    type SupportedDataParser = DP.DataParser;
     export const contractKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response-contract", unknown>>;
-    export interface Contract<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericSchema extends DP.DataParser = DP.DataParser> extends Kind<typeof contractKind.definition> {
+    export interface Contract<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericSchema extends SupportedDataParser = SupportedDataParser> extends Kind<typeof contractKind.definition> {
         code: GenericCode;
         information: GenericInformation;
         body: GenericSchema;
     }
-    export type Convert<GenericContract extends Contract> = GenericContract extends Contract ? Response<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["body"]>> : never;
-    export const http100Continue: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    export type Convert<GenericContract extends Contract> = GenericContract extends Contract ? PredictedResponse<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["body"]>> : never;
+    export const http100Continue: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"100", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const switchingProtocols: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"100", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const switchingProtocols: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"101", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const processing: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"101", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const processing: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"102", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const earlyHints: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"102", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const earlyHints: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"103", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const ok: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation, schema: GenericSchema) => NoInfer<Contract<"200", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const created: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"103", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const ok: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation, schema: GenericSchema & ForbiddenBigintDataParser<GenericSchema>) => NoInfer<Contract<"200", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const created: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"201", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const accepted: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"201", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const accepted: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"202", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const nonAuthoritativeInformation: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"202", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const nonAuthoritativeInformation: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"203", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const noContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"204", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const resetContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"203", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const noContent: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"204", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const resetContent: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"205", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const partialContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"205", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const partialContent: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"206", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const multiStatus: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"206", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const multiStatus: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"207", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const alreadyReported: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"207", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const alreadyReported: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"208", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const imUsed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"208", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const imUsed: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"226", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const multipleChoices: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"300", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const movedPermanently: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"301", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const found: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"302", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const seeOther: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"303", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const notModified: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"304", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const useProxy: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"305", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const switchProxy: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"306", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const temporaryRedirect: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"307", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const permanentRedirect: <GenericInformation extends string, GenericSchema extends DP.DataParser = never>(information: GenericInformation) => NoInfer<Contract<"308", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const badRequest: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"226", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const multipleChoices: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"300", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const movedPermanently: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"301", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const found: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"302", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const seeOther: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"303", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notModified: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"304", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const useProxy: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"305", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const switchProxy: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"306", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const temporaryRedirect: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"307", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const permanentRedirect: <GenericInformation extends string, GenericSchema extends SupportedDataParser = never>(information: GenericInformation) => NoInfer<Contract<"308", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const badRequest: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"400", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const unauthorized: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"400", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unauthorized: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"401", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const paymentRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"401", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const paymentRequired: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"402", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const forbidden: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"402", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const forbidden: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"403", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const notFound: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"403", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notFound: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"404", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const methodNotAllowed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"404", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const methodNotAllowed: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"405", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const notAcceptable: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"405", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notAcceptable: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"406", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const proxyAuthenticationRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"406", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const proxyAuthenticationRequired: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"407", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const requestTimeout: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"407", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const requestTimeout: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"408", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const conflict: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"408", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const conflict: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"409", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const gone: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"409", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const gone: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"410", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const lengthRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"410", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const lengthRequired: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"411", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const preconditionFailed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"411", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const preconditionFailed: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"412", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const contentTooLarge: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"412", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const contentTooLarge: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"413", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const uriTooLong: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"413", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const uriTooLong: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"414", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const unsupportedMediaType: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"414", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unsupportedMediaType: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"415", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const rangeNotSatisfiable: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"415", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const rangeNotSatisfiable: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"416", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const expectationFailed: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"416", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const expectationFailed: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"417", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const imATeapot: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"417", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const imATeapot: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"418", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const misdirectedRequest: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"418", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const misdirectedRequest: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"421", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const unprocessableContent: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"421", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unprocessableContent: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"422", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const locked: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"422", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const locked: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"423", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const failedDependency: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"423", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const failedDependency: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"424", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const tooEarly: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"424", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const tooEarly: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"425", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const upgradeRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"425", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const upgradeRequired: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"426", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const preconditionRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"426", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const preconditionRequired: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"428", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const tooManyRequests: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"428", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const tooManyRequests: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"429", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const requestHeaderFieldsTooLarge: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"429", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const requestHeaderFieldsTooLarge: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"431", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const unavailableForLegalReasons: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"431", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const unavailableForLegalReasons: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"451", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const internalServerError: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"451", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const internalServerError: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"500", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const notImplemented: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"500", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notImplemented: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"501", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const badGateway: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"501", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const badGateway: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"502", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const serviceUnavailable: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"502", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const serviceUnavailable: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"503", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const gatewayTimeout: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"503", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const gatewayTimeout: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"504", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const httpVersionNotSupported: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"504", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const httpVersionNotSupported: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"505", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const variantAlsoNegotiates: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"505", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const variantAlsoNegotiates: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"506", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const insufficientStorage: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"506", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const insufficientStorage: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"507", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const loopDetected: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"507", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const loopDetected: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"508", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const notExtended: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"508", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const notExtended: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"510", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
-    export const networkAuthenticationRequired: <GenericInformation extends string, GenericSchema extends DP.DataParser = DP.DataParserEmpty<{
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"510", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const networkAuthenticationRequired: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
         readonly checkers: readonly [];
-    }>>(information: GenericInformation, schema?: GenericSchema | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
     const Error_base: new (params: {
         "@DuplojsHttpCore/contract-error"?: unknown;
     }, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;

package/dist/core/response/contract.mjs

@@ -1,7 +1,7 @@
 import { pipe, DP, kindHeritage } from '@duplojs/utils';
 import { createCoreLibKind } from '../kind.mjs';
 
-const errorClass = Error;
+const ErrorClass = Error;
 var ResponseContract;
 (function (ResponseContract) {
     ResponseContract.contractKind = createCoreLibKind("response-contract");
@@ -76,7 +76,7 @@ var ResponseContract;
     ResponseContract.loopDetected = createContractBuilder("508", { defaultSchema });
     ResponseContract.notExtended = createContractBuilder("510", { defaultSchema });
     ResponseContract.networkAuthenticationRequired = createContractBuilder("511", { defaultSchema });
-    class Error extends kindHeritage("contract-error", createCoreLibKind("contract-error"), errorClass) {
+    class Error extends kindHeritage("contract-error", createCoreLibKind("contract-error"), ErrorClass) {
         information;
         dataParserError;
         constructor(information, dataParserError) {

package/dist/core/{route/hooks/response.cjs → response/hook.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var kind = require('../../kind.cjs');
-var index = require('../../response/index.cjs');
+var kind = require('../kind.cjs');
+require('./index.cjs');
 var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
 
 const defaultParamsParent = [undefined, undefined, undefined];
 const defaultParams = {};
-class HookResponse extends utils.kindHeritage("hook-response", kind.createCoreLibKind("hook-response"), index.Response) {
+class HookResponse extends utils.kindHeritage("hook-response", kind.createCoreLibKind("hook-response"), base.Response) {
     code;
     information;
     body;

package/dist/core/{route/hooks/response.d.ts → response/hook.d.ts}

@@ -1,5 +1,5 @@
-import { type ResponseCode, Response } from "../../response";
-import { type HookRouteLifeCycle } from ".";
+import { type ResponseCode, Response } from "../response";
+import { type HookRouteLifeCycle } from "../route/hooks";
 declare const HookResponse_base: new (params: {
     "@DuplojsHttpCore/hook-response"?: unknown;
 }, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;

package/dist/core/{route/hooks/response.mjs → response/hook.mjs}

@@ -1,6 +1,7 @@
-import { createCoreLibKind } from '../../kind.mjs';
-import { Response } from '../../response/index.mjs';
+import { createCoreLibKind } from '../kind.mjs';
+import './index.mjs';
 import { kindHeritage } from '@duplojs/utils';
+import { Response } from './base.mjs';
 
 const defaultParamsParent = [undefined, undefined, undefined];
 const defaultParams = {};

package/dist/core/response/index.cjs

@@ -1,45 +1,16 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
-var kind = require('../kind.cjs');
+var base = require('./base.cjs');
 var contract = require('./contract.cjs');
+var hook = require('./hook.cjs');
+var predicted = require('./predicted.cjs');
 
-class Response extends utils.kindHeritage("response", kind.createCoreLibKind("response")) {
-    code;
-    information;
-    body;
-    headers = undefined;
-    constructor(code, information, body) {
-        super();
-        this.code = code;
-        this.information = information;
-        this.body = body;
-    }
-    setHeaders(headers) {
-        this.headers = utils.O.override(this.headers ?? {}, headers);
-        return this;
-    }
-    setHeader(key, header) {
-        if (!this.headers) {
-            this.headers = {};
-        }
-        if (typeof header !== "undefined") {
-            this.headers[key] = header;
-        }
-        return this;
-    }
-    deleteHeader(key) {
-        if (!this.headers) {
-            return this;
-        }
-        const { [key]: deleteHeader, ...rest } = this.headers;
-        this.headers = rest;
-        return this;
-    }
-}
 
+
+exports.Response = base.Response;
 Object.defineProperty(exports, "ResponseContract", {
-    enumerable: true,
-    get: function () { return contract.ResponseContract; }
+	enumerable: true,
+	get: function () { return contract.ResponseContract; }
 });
-exports.Response = Response;
+exports.HookResponse = hook.HookResponse;
+exports.PredictedResponse = predicted.PredictedResponse;

package/dist/core/response/index.d.ts

@@ -1,21 +1,4 @@
-import { type S } from "@duplojs/utils";
+export * from "./base";
 export * from "./contract";
-export type InformationResponseCode = `1${S.Digit}${S.Digit}`;
-export type SuccessResponseCode = `2${S.Digit}${S.Digit}`;
-export type RedirectionResponseCode = `3${S.Digit}${S.Digit}`;
-export type ClientErrorResponseCode = `4${S.Digit}${S.Digit}`;
-export type ServerErrorResponseCode = `5${S.Digit}${S.Digit}`;
-export type ResponseCode = (InformationResponseCode | SuccessResponseCode | RedirectionResponseCode | ClientErrorResponseCode | ServerErrorResponseCode);
-declare const Response_base: new (params?: {
-    "@DuplojsHttpCore/response"?: unknown;
-} | undefined) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"response", unknown>, unknown>;
-export declare class Response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends Response_base {
-    code: GenericCode;
-    information: GenericInformation;
-    body: GenericBody;
-    headers: Record<string, string | string[]> | undefined;
-    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
-    setHeaders(headers: Partial<Record<string, string | string[]>>): this;
-    setHeader(key: string, header?: string | string[]): this;
-    deleteHeader(key: string): this;
-}
+export * from "./hook";
+export * from "./predicted";