@duplojs/utils 1.4.33 → 1.4.35

package/dist/dataParser/identifier.d.ts

@@ -59,7 +59,7 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: unknown[];
         output: unknown[];
-    }>>, GenericInput extends DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    }>>, GenericInput extends unknown, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
     <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
         output: string;
@@ -111,5 +111,5 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: unknown[];
         output: unknown[];
-    }>>, GenericInput extends DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    }>>, GenericInput extends unknown, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/dataParser/parsers/array/index.d.ts

@@ -21,10 +21,6 @@ export interface DataParserArray<GenericDefinition extends DataParserDefinitionA
         DataParserArrayCheckers<Output<this>>,
         ...DataParserArrayCheckers<Output<this>>[]
     ], GenericChecker>): DataParserArray<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionArray>(definition: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, GenericDefinition>>;
 }
 /**
  * Creates a data parser for arrays of a given element parser.

package/dist/dataParser/parsers/bigint/index.d.ts

@@ -21,10 +21,6 @@ export interface DataParserBigInt<GenericDefinition extends DataParserDefinition
         DataParserBigIntCheckers,
         ...DataParserBigIntCheckers[]
     ], GenericChecker>): DataParserBigInt<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionBigInt>(definition: GenericDefinition): DataParserBigInt<MergeDefinition<DataParserDefinitionBigInt, GenericDefinition>>;
 }
 /**
  * Creates a data parser for bigint values.

package/dist/dataParser/parsers/boolean.d.ts

@@ -19,10 +19,6 @@ export interface DataParserBoolean<GenericDefinition extends DataParserDefinitio
         DataParserBooleanCheckers,
         ...DataParserBooleanCheckers[]
     ], GenericChecker>): DataParserBoolean<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionBoolean>(definition: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, GenericDefinition>>;
 }
 /**
  * Creates a data parser for boolean values.

package/dist/dataParser/parsers/date.d.ts

@@ -20,10 +20,6 @@ export interface DataParserDate<GenericDefinition extends DataParserDefinitionDa
         DataParserDateCheckers,
         ...DataParserDateCheckers[]
     ], GenericChecker>): DataParserDate<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionDate>(definition: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, GenericDefinition>>;
 }
 /**
  * Creates a data parser for TheDate values.

package/dist/dataParser/parsers/empty.d.ts

@@ -19,10 +19,6 @@ export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionE
         DataParserEmptyCheckers,
         ...DataParserEmptyCheckers[]
     ], GenericChecker>): DataParserEmpty<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionEmpty>(definition: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, GenericDefinition>>;
 }
 /**
  * Creates a data parser that accepts undefined.

package/dist/dataParser/parsers/lazy.d.ts

@@ -19,10 +19,6 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
         DataParserLazyCheckers<Output<this>>,
         ...DataParserLazyCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLazy<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionLazy>(definition: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, GenericDefinition>>;
 }
 /**
  * Creates a lazy data parser resolved at runtime.

package/dist/dataParser/parsers/literal.d.ts

@@ -20,10 +20,6 @@ export interface DataParserLiteral<GenericDefinition extends DataParserDefinitio
         DataParserLiteralCheckers<Output<this>>,
         ...DataParserLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, GenericDefinition>>;
 }
 /**
  * Creates a data parser for a literal value.

package/dist/dataParser/parsers/nil.d.ts

@@ -19,10 +19,6 @@ export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil
         DataParserNilCheckers,
         ...DataParserNilCheckers[]
     ], GenericChecker>): DataParserNil<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionNil>(definition: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, GenericDefinition>>;
 }
 /**
  * Creates a data parser that accepts null.

package/dist/dataParser/parsers/nullable.d.ts

@@ -20,10 +20,6 @@ export interface DataParserNullable<GenericDefinition extends DataParserDefiniti
         DataParserNullableCheckers<Output<this>>,
         ...DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullable<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionNullable>(definition: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, GenericDefinition>>;
 }
 /**
  * Creates a data parser that accepts null or the inner parser output.

package/dist/dataParser/parsers/number/index.d.ts

@@ -21,10 +21,6 @@ export interface DataParserNumber<GenericDefinition extends DataParserDefinition
         DataParserNumberCheckers,
         ...DataParserNumberCheckers[]
     ], GenericChecker>): DataParserNumber<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionNumber>(definition: GenericDefinition): DataParserNumber<MergeDefinition<DataParserDefinitionNumber, GenericDefinition>>;
 }
 /**
  * Creates a data parser for numbers.

package/dist/dataParser/parsers/object/index.d.ts

@@ -36,10 +36,6 @@ export interface DataParserObject<GenericDefinition extends DataParserDefinition
         DataParserObjectCheckers<Output<this>>,
         ...DataParserObjectCheckers<Output<this>>[]
     ], GenericChecker>): DataParserObject<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionObject>(definition: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, GenericDefinition>>;
 }
 /**
  * Creates a data parser for objects with a defined shape.

package/dist/dataParser/parsers/optional.d.ts

@@ -20,10 +20,6 @@ export interface DataParserOptional<GenericDefinition extends DataParserDefiniti
         DataParserOptionalCheckers<Output<this>>,
         ...DataParserOptionalCheckers<Output<this>>[]
     ], GenericChecker>): DataParserOptional<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionOptional>(definition: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, GenericDefinition>>;
 }
 /**
  * Creates a data parser that accepts undefined or the inner parser output.

package/dist/dataParser/parsers/pipe.d.ts

@@ -20,10 +20,6 @@ export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPi
         DataParserPipeCheckers<Output<this>>,
         ...DataParserPipeCheckers<Output<this>>[]
     ], GenericChecker>): DataParserPipe<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionPipe>(definition: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, GenericDefinition>>;
 }
 /**
  * Creates a data parser pipeline from an input parser to an output parser.

package/dist/dataParser/parsers/record/index.d.ts

@@ -35,10 +35,6 @@ export interface DataParserRecord<GenericDefinition extends DataParserDefinition
         DataParserRecordCheckers<Output<this>>,
         ...DataParserRecordCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecord<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionRecord>(definition: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, GenericDefinition>>;
 }
 /**
  * Creates a data parser for records with key and value parsers.

package/dist/dataParser/parsers/recover.d.ts

@@ -20,10 +20,6 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
         DataParserRecoverCheckers<Output<this>>,
         ...DataParserRecoverCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecover<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionRecover>(definition: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, GenericDefinition>>;
 }
 /**
  * Creates a data parser that recovers with a fallback value on error.

package/dist/dataParser/parsers/string/index.d.ts

@@ -21,10 +21,6 @@ export interface DataParserString<GenericDefinition extends DataParserDefinition
         DataParserStringCheckers,
         ...DataParserStringCheckers[]
     ], GenericChecker>): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionString>(definition: GenericDefinition): DataParserString<MergeDefinition<DataParserDefinitionString, GenericDefinition>>;
 }
 /**
  * Creates a data parser for strings.

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.cjs

@@ -41,9 +41,9 @@ function createTemplateLiteralPattern(templatePart) {
         int: innerPipe.innerPipe(find.find(int.checkerIntKind.has), when$1.when(int.checkerIntKind.has, justReturn.justReturn(true))),
     }), ({ int }) => {
         if (int) {
-            return "(?:[0-9]+)";
+            return "(?:-?[0-9]+)";
         }
-        return "(?:[0-9]+(\\.[0-9]+)?)";
+        return "(?:-?[0-9]+(?:\\.[0-9]+)?)";
     })), when.when(index$2.bigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.booleanKind.has, () => "(?:true|false)"), when.when(nil.nilKind.has, () => "(?:null)"), when.when(empty.emptyKind.has, () => "(?:undefined)"), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map((element) => createTemplateLiteralPattern([element])), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index$1.stringKind.has, (dataParser) => pipe.pipe(dataParser.definition.checkers, to.to({
         email: innerPipe.innerPipe(find.find(email.checkerEmailKind.has), when$1.when(email.checkerEmailKind.has, (checker) => pipe.pipe(checker.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, "")))),
         min: innerPipe.innerPipe(find.find(min.checkerStringMinKind.has), when$1.when(min.checkerStringMinKind.has, (checker) => checker.definition.min)),

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.mjs

@@ -39,9 +39,9 @@ function createTemplateLiteralPattern(templatePart) {
         int: innerPipe(find(checkerIntKind.has), when$1(checkerIntKind.has, justReturn(true))),
     }), ({ int }) => {
         if (int) {
-            return "(?:[0-9]+)";
+            return "(?:-?[0-9]+)";
         }
-        return "(?:[0-9]+(\\.[0-9]+)?)";
+        return "(?:-?[0-9]+(?:\\.[0-9]+)?)";
     })), when(bigIntKind.has, () => "(?:[0-9]+n)"), when(booleanKind.has, () => "(?:true|false)"), when(nilKind.has, () => "(?:null)"), when(emptyKind.has, () => "(?:undefined)"), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map((element) => createTemplateLiteralPattern([element])), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, (dataParser) => pipe(dataParser.definition.checkers, to({
         email: innerPipe(find(checkerEmailKind.has), when$1(checkerEmailKind.has, (checker) => pipe(checker.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, "")))),
         min: innerPipe(find(checkerStringMinKind.has), when$1(checkerStringMinKind.has, (checker) => checker.definition.min)),

package/dist/dataParser/parsers/templateLiteral/index.d.ts

@@ -1,4 +1,4 @@
-import { type Adaptor, type AnyTuple, type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../../common";
+import { type Adaptor, type AnyTuple, type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserCheckerStringMax, type DataParserCheckerStringMin, type DataParserCheckerStringRegex, type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "../string";
@@ -13,26 +13,26 @@ import { type DataParserDefinitionUnion, type DataParserUnion } from "../union";
 import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./createTemplateLiteralPattern";
 export type TemplateLiteralPrimitiveParts = (string | number | null | undefined | bigint | boolean);
-export type TemplateLiteralParts = (TemplateLiteralPrimitiveParts | DataParserString<Omit<DataParserDefinitionString, "checkers"> & {
+export type TemplateLiteralParts = (TemplateLiteralPrimitiveParts | DataParserString<SimplifyTopLevel<Omit<DataParserDefinitionString, "checkers"> & {
     readonly checkers: readonly (DataParserCheckerEmail | DataParserCheckerStringMax | DataParserCheckerStringMin | DataParserCheckerStringRegex)[];
-}> | DataParserNumber<Omit<DataParserDefinitionNumber, "checkers"> & {
+}>> | DataParserNumber<SimplifyTopLevel<Omit<DataParserDefinitionNumber, "checkers"> & {
     readonly checkers: readonly DataParserCheckerInt[];
-}> | DataParserBigInt<Omit<DataParserDefinitionBigInt, "checkers"> & {
+}>> | DataParserBigInt<SimplifyTopLevel<Omit<DataParserDefinitionBigInt, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserBoolean<Omit<DataParserDefinitionBoolean, "checkers"> & {
+}>> | DataParserBoolean<SimplifyTopLevel<Omit<DataParserDefinitionBoolean, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserLiteral<Omit<DataParserDefinitionLiteral, "checkers"> & {
+}>> | DataParserLiteral<SimplifyTopLevel<Omit<DataParserDefinitionLiteral, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserEmpty<Omit<DataParserDefinitionEmpty, "checkers"> & {
+}>> | DataParserEmpty<SimplifyTopLevel<Omit<DataParserDefinitionEmpty, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserNil<Omit<DataParserDefinitionNil, "checkers"> & {
+}>> | DataParserNil<SimplifyTopLevel<Omit<DataParserDefinitionNil, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserTemplateLiteral<Omit<DataParserDefinitionTemplateLiteral, "checkers"> & {
+}>> | DataParserTemplateLiteral<SimplifyTopLevel<Omit<DataParserDefinitionTemplateLiteral, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserUnion<Omit<DataParserDefinitionUnion, "checkers" | "options"> & {
+}>> | DataParserUnion<SimplifyTopLevel<Omit<DataParserDefinitionUnion, "checkers" | "options"> & {
     readonly options: AnyTuple<Exclude<TemplateLiteralParts, TemplateLiteralPrimitiveParts>>;
     readonly checkers: readonly [];
-}>);
+}>>);
 export type TemplateLiteralShape = readonly [TemplateLiteralParts, ...TemplateLiteralParts[]];
 type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
 export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
@@ -60,10 +60,6 @@ export interface DataParserTemplateLiteral<GenericDefinition extends DataParserD
         DataParserTemplateLiteralCheckers<Output<this>>,
         ...DataParserTemplateLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTemplateLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTemplateLiteral>(definition: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, GenericDefinition>>;
 }
 /**
  * Creates a data parser for deterministic template literal strings.

package/dist/dataParser/parsers/time/index.d.ts

@@ -22,10 +22,6 @@ export interface DataParserTime<GenericDefinition extends DataParserDefinitionTi
         DataParserTimeCheckers,
         ...DataParserTimeCheckers[]
     ], GenericChecker>): DataParserTime<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTime>(definition: GenericDefinition): DataParserTime<MergeDefinition<DataParserDefinitionTime, GenericDefinition>>;
 }
 /**
  * Creates a data parser for TheTime values.

package/dist/dataParser/parsers/transform.d.ts

@@ -21,10 +21,6 @@ export interface DataParserTransform<GenericDefinition extends DataParserDefinit
         DataParserTransformCheckers<Output<this>>,
         ...DataParserTransformCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTransform<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTransform>(definition: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, GenericDefinition>>;
 }
 /**
  * Creates a data parser that transforms the output of another parser.

package/dist/dataParser/parsers/tuple.d.ts

@@ -36,10 +36,6 @@ export interface DataParserTuple<GenericDefinition extends DataParserDefinitionT
         DataParserTupleCheckers<Output<this>>,
         ...DataParserTupleCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTuple<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTuple>(definition: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, GenericDefinition>>;
 }
 /**
  * Creates a data parser for tuples with a fixed shape.

package/dist/dataParser/parsers/union.d.ts

@@ -20,10 +20,6 @@ export interface DataParserUnion<GenericDefinition extends DataParserDefinitionU
         DataParserUnionCheckers<Output<this>>,
         ...DataParserUnionCheckers<Output<this>>[]
     ], GenericChecker>): DataParserUnion<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionUnion>(definition: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, GenericDefinition>>;
 }
 /**
  * Creates a data parser that accepts one of multiple parsers.

package/dist/dataParser/parsers/unknown.d.ts

@@ -18,10 +18,6 @@ export interface DataParserUnknown<GenericDefinition extends DataParserDefinitio
         DataParserUnknownCheckers,
         ...DataParserUnknownCheckers[]
     ], GenericChecker>): DataParserUnknown<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionUnknown>(definition: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, GenericDefinition>>;
 }
 /**
  * Creates a data parser that accepts any value.

package/dist/dataParser/types/addCheckersToDefinition.d.ts

@@ -1,5 +1,5 @@
-import { type AnyTuple, type SimplifyTopLevel } from "../../common";
+import { type SimplifyTopLevel } from "../../common";
 import { type DataParserChecker, type DataParserDefinition } from "../base";
 export type AddCheckersToDefinition<GenericDefinition extends DataParserDefinition, GenericChecker extends readonly [DataParserChecker, ...DataParserChecker[]]> = SimplifyTopLevel<Omit<GenericDefinition, "checkers"> & {
-    readonly checkers: GenericDefinition["checkers"] extends AnyTuple ? readonly [...GenericDefinition["checkers"], ...GenericChecker] : GenericChecker;
+    readonly checkers: readonly [...GenericDefinition["checkers"], ...GenericChecker];
 }>;

package/dist/either/future/create.d.ts

@@ -7,12 +7,12 @@ import { type AnyValue } from "../../common";
 type Either = EitherRight | EitherLeft;
 type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? EitherFutureSuccess<Exclude<GenericValue, Either>> : never;
 type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Future<any> ? GenericValue : GenericValue extends Promise<unknown> ? EitherFutureError : never;
-type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = (Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>);
+type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = Extract<(Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>), any>;
 export type FutureEitherAllResult<GenericArray extends readonly unknown[] | []> = Future<{
     -readonly [Prop in keyof GenericArray]: Awaited<Future<GenericArray[Prop]>>;
 }>;
 declare const kind = "kind-future-either";
-export declare class Future<const GenericValue extends unknown = unknown> extends Promise<ComputeFutureEitherResult<GenericValue>> {
+export declare class Future<const GenericValue extends unknown = unknown> extends Promise<Extract<ComputeFutureEitherResult<GenericValue>, any>> {
     constructor(value: GenericValue);
     [kind]: unknown;
     then<TResult1 = Extract<ComputeFutureEitherResult<GenericValue>, any>, TResult2 = never>(onfulfilled?: ((value: Extract<ComputeFutureEitherResult<GenericValue>, any>) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult1 | TResult2>;

package/dist/either/right/asyncPipe.d.ts

@@ -15,17 +15,13 @@ export type EitherRightAsyncPipeResult<GenericPipeOutputs extends AnyValue, Gene
  * The input value is not mutated.
  * 
  * ```ts
- * const input = E.future(
- * 	Promise.resolve(
- * 		true
- * 			? false
- * 				? true
- * 					? E.right("right-1", 1)
- * 					: E.left("left-1", null)
- * 				: E.right("right-2", 2)
- * 			: E.left("left-2", 2),
- * 	),
- * );
+ * import { E } from "../..";
+ * 
+ * const input: Promise<
+ * 	| E.EitherFail
+ * 	| E.EitherNullableEmpty
+ * 	| E.EitherRight<"right", 1>
+ * > = Promise.resolve(E.right("right", 1));
  * 
  * const result = E.rightAsyncPipe(
  * 	input,

package/dist/either/right/pipe.d.ts

@@ -13,13 +13,13 @@ export type EitherRightPipeResult<GenericPipeOutputs extends AnyValue, GenericLa
  * The input value is not mutated.
  * 
  * ```ts
- * const input = true
- * 	? false
- * 		? true
- * 			? E.right("right-1", 1)
- * 			: E.left("left-1", null)
- * 		: E.right("right-2", 2)
- * 	: E.left("left-2", 2);
+ * import { E } from "../..";
+ * 
+ * const input: (
+ * 	| E.EitherFail
+ * 	| E.EitherNullableEmpty
+ * 	| E.EitherRight<"right", 1>
+ * ) = E.right("right", 1);
  * 
  * const result = E.rightPipe(
  * 	input,

package/dist/metadata.json

@@ -4401,6 +4401,9 @@
                 {
                   "name": "array.d.ts"
                 },
+                {
+                  "name": "function.d.ts"
+                },
                 {
                   "name": "index.d.ts"
                 },
@@ -4421,6 +4424,9 @@
                 {
                   "name": "array.d.ts"
                 },
+                {
+                  "name": "function.d.ts"
+                },
                 {
                   "name": "getIncompleteUnion.d.ts"
                 },
@@ -4517,6 +4523,15 @@
         },
         {
           "name": "when.mjs"
+        },
+        {
+          "name": "whenNot.cjs"
+        },
+        {
+          "name": "whenNot.d.ts"
+        },
+        {
+          "name": "whenNot.mjs"
         }
       ]
     },

package/dist/object/countKeys.cjs

@@ -3,6 +3,9 @@
 var wrapValue = require('../common/wrapValue.cjs');
 var kind = require('../common/kind.cjs');
 
+/**
+ * {@include object/countKeys/index.md}
+ */
 function countKeys(object) {
     return Object.keys(object)
         .filter((key) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key))

package/dist/object/countKeys.d.ts

@@ -1 +1,28 @@
+/**
+ * Counts the number of an object's keys while ignoring internal runtime keys.
+ * 
+ * **Supported call styles:**
+ * - Classic: `countKeys(object)` -> returns a number
+ * - Curried: not available (use `pipe(object, O.countKeys)` for composition)
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.countKeys(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 	},
+ * ); // 2
+ * ```
+ * 
+ * @remarks
+ * - Filters runtime keys used by the library
+ * - Uses the same semantics as [`Object.keys`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/object/countKeys
+ * 
+ * @namespace O
+ * 
+ */
 export declare function countKeys<GenericObject extends object>(object: GenericObject): number;

package/dist/object/countKeys.mjs

@@ -1,6 +1,9 @@
 import { isRuntimeWrappedValueKey } from '../common/wrapValue.mjs';
 import { isRuntimeKind } from '../common/kind.mjs';
 
+/**
+ * {@include object/countKeys/index.md}
+ */
 function countKeys(object) {
     return Object.keys(object)
         .filter((key) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key))