@duplojs/http 0.1.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;
-        schema: GenericSchema;
+        body: GenericSchema;
     }
-    export type Convert<GenericContract extends Contract> = GenericContract extends Contract ? Response<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["schema"]>> : 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 { DP, kindHeritage, pipe } from '@duplojs/utils';
+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");
@@ -9,7 +9,7 @@ var ResponseContract;
         return (information, ...[schema]) => pipe({
             code,
             information,
-            schema: (schema ?? options?.defaultSchema ?? DP.empty()),
+            body: (schema ?? options?.defaultSchema ?? DP.empty()),
         }, ResponseContract.contractKind.setTo);
     }
     const defaultSchema = DP.empty();
@@ -21,21 +21,21 @@ var ResponseContract;
     ResponseContract.created = createContractBuilder("201", { defaultSchema });
     ResponseContract.accepted = createContractBuilder("202", { defaultSchema });
     ResponseContract.nonAuthoritativeInformation = createContractBuilder("203", { defaultSchema });
-    ResponseContract.noContent = createContractBuilder("204", { });
+    ResponseContract.noContent = createContractBuilder("204", { noSchema: true });
     ResponseContract.resetContent = createContractBuilder("205", { defaultSchema });
     ResponseContract.partialContent = createContractBuilder("206", { defaultSchema });
     ResponseContract.multiStatus = createContractBuilder("207", { defaultSchema });
     ResponseContract.alreadyReported = createContractBuilder("208", { defaultSchema });
     ResponseContract.imUsed = createContractBuilder("226", { defaultSchema });
-    ResponseContract.multipleChoices = createContractBuilder("300", { });
-    ResponseContract.movedPermanently = createContractBuilder("301", { });
-    ResponseContract.found = createContractBuilder("302", { });
-    ResponseContract.seeOther = createContractBuilder("303", { });
-    ResponseContract.notModified = createContractBuilder("304", { });
-    ResponseContract.useProxy = createContractBuilder("305", { });
-    ResponseContract.switchProxy = createContractBuilder("306", { });
-    ResponseContract.temporaryRedirect = createContractBuilder("307", { });
-    ResponseContract.permanentRedirect = createContractBuilder("308", { });
+    ResponseContract.multipleChoices = createContractBuilder("300", { noSchema: true });
+    ResponseContract.movedPermanently = createContractBuilder("301", { noSchema: true });
+    ResponseContract.found = createContractBuilder("302", { noSchema: true });
+    ResponseContract.seeOther = createContractBuilder("303", { noSchema: true });
+    ResponseContract.notModified = createContractBuilder("304", { noSchema: true });
+    ResponseContract.useProxy = createContractBuilder("305", { noSchema: true });
+    ResponseContract.switchProxy = createContractBuilder("306", { noSchema: true });
+    ResponseContract.temporaryRedirect = createContractBuilder("307", { noSchema: true });
+    ResponseContract.permanentRedirect = createContractBuilder("308", { noSchema: true });
     ResponseContract.badRequest = createContractBuilder("400", { defaultSchema });
     ResponseContract.unauthorized = createContractBuilder("401", { defaultSchema });
     ResponseContract.paymentRequired = createContractBuilder("402", { defaultSchema });
@@ -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;
@@ -14,7 +15,7 @@ class HookResponse extends utils.kindHeritage("hook-response", kind.createCoreLi
     constructor(from, code, information, body) {
         super(defaultParams, defaultParamsParent);
         this.code = code;
-        this.information = `from-hook-${information}`;
+        this.information = information;
         this.body = body;
         this.fromHook = from;
     }

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

@@ -1,11 +1,11 @@
-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>;
 export declare class HookResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends HookResponse_base {
     code: GenericCode;
-    information: `from-hook-${GenericInformation}`;
+    information: GenericInformation;
     body: GenericBody;
     fromHook: keyof HookRouteLifeCycle;
     constructor(from: keyof HookRouteLifeCycle, code: GenericCode, information: GenericInformation, body: GenericBody);

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 = {};
@@ -12,7 +13,7 @@ class HookResponse extends kindHeritage("hook-response", createCoreLibKind("hook
     constructor(from, code, information, body) {
         super(defaultParams, defaultParamsParent);
         this.code = code;
-        this.information = `from-hook-${information}`;
+        this.information = information;
         this.body = body;
         this.fromHook = from;
     }