@duplojs/lang 0.0.1-beta.2 → 0.0.1-beta.3

package/dist/dataStructure/structure/identifier.d.ts

@@ -1,5 +1,7 @@
 import { Structure } from './base';
+import { Structures } from './types';
+import * as DKind from '../../kind';
 export declare const structureIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", String>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').ObjectTag<string>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>> extends true ? Extract<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, GenericGroupedKind> | Extract<import('..').NonEncodableStringStructure, GenericGroupedKind> | Extract<import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityStructure<string, Record<string, unknown>>, GenericGroupedKind> | Extract<import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>>, GenericGroupedKind> | Extract<import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", String>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').ObjectTag<string>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>> extends true ? Extract<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, GenericGroupedKind> | Extract<import('..').NonEncodableStringStructure, GenericGroupedKind> | Extract<import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityStructure<string, Record<string, unknown>>, GenericGroupedKind> | Extract<import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>>, GenericGroupedKind> | Extract<import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').ObjectTag<string>>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", String>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends GenericKindHandler extends DKind.Handler<DKind.Definition<string, unknown>> ? DKind.Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (GenericInput extends Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>> ? (Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>> extends infer T ? T extends Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>> ? T extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> extends infer T_1 ? T_1 extends import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> ? T_1 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]> extends infer T_2 ? T_2 extends import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]> ? T_2 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_3 ? T_3 extends import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_3 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('../../modeling').EntityStructure<string, Record<string, unknown>> extends infer T_4 ? T_4 extends import('../../modeling').EntityStructure<string, Record<string, unknown>> ? T_4 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>> extends infer T_5 ? T_5 extends import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>> ? T_5 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_6 ? T_6 extends import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_6 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> extends infer T_7 ? T_7 extends import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> ? T_7 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_8 ? T_8 extends import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_8 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').NonEncodableStringStructure extends infer T_9 ? T_9 extends import('..').NonEncodableStringStructure ? T_9 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_10 ? T_10 extends import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_10 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').ObjectTag<string>>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", String>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends GenericKindHandler extends DKind.Handler<DKind.Definition<string, unknown>> ? DKind.Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (GenericInput extends Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>> ? (Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>> extends infer T ? T extends Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>> ? T extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> extends infer T_1 ? T_1 extends import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> ? T_1 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]> extends infer T_2 ? T_2 extends import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]> ? T_2 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_3 ? T_3 extends import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_3 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('../../modeling').EntityStructure<string, Record<string, unknown>> extends infer T_4 ? T_4 extends import('../../modeling').EntityStructure<string, Record<string, unknown>> ? T_4 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>> extends infer T_5 ? T_5 extends import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>> ? T_5 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_6 ? T_6 extends import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_6 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> extends infer T_7 ? T_7 extends import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]> ? T_7 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_8 ? T_8 extends import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_8 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('..').NonEncodableStringStructure extends infer T_9 ? T_9 extends import('..').NonEncodableStringStructure ? T_9 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) | (import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> extends infer T_10 ? T_10 extends import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]> ? T_10 extends GenericInput ? GenericInput & Structures extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Structures : never : never : never : never) : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/dataStructure/type/defaults/bigint.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const bigintTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-type", unknown>>;
 export interface BigintTypeDefinition extends TypeDefinition {
 }
-export interface BigintType extends DCommon.UnionToIntersection<Type<FundamentalType.TheBigint, bigint, BigintTypeDefinition> & DKind.Kind<typeof bigintTypeKind>> {
+export interface BigintType extends DCommon.Forward<Type<FundamentalType.TheBigint, bigint, BigintTypeDefinition> & DKind.Kind<typeof bigintTypeKind>> {
 }
 export declare const BigintType: () => BigintType;

package/dist/dataStructure/type/defaults/bigintLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const bigintLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface BigintLiteralTypeDefinition extends TypeDefinition {
     value: bigint;
 }
-export interface BigintLiteralType<GenericValue extends bigint = bigint> extends DCommon.UnionToIntersection<Type<FundamentalType.TheBigint, GenericValue, BigintLiteralTypeDefinition> & DKind.Kind<typeof bigintLiteralTypeKind>> {
+export interface BigintLiteralType<GenericValue extends bigint = bigint> extends DCommon.Forward<Type<FundamentalType.TheBigint, GenericValue, BigintLiteralTypeDefinition> & DKind.Kind<typeof bigintLiteralTypeKind>> {
 }
 export declare const BigintLiteralType: <const GenericBigint extends bigint>(value: GenericBigint) => BigintLiteralType<GenericBigint>;

package/dist/dataStructure/type/defaults/boolean.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const booleanTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-type", unknown>>;
 export interface BooleanTypeDefinition extends TypeDefinition {
 }
-export interface BooleanType extends DCommon.UnionToIntersection<Type<FundamentalType.TheBoolean, boolean, BooleanTypeDefinition> & DKind.Kind<typeof booleanTypeKind>> {
+export interface BooleanType extends DCommon.Forward<Type<FundamentalType.TheBoolean, boolean, BooleanTypeDefinition> & DKind.Kind<typeof booleanTypeKind>> {
 }
 export declare const BooleanType: () => BooleanType;

package/dist/dataStructure/type/defaults/booleanLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const booleanLiteralTypeKind: DKind.Handler<DKind.Definition<"@Du
 export interface BooleanLiteralTypeDefinition extends TypeDefinition {
     value: boolean;
 }
-export interface BooleanLiteralType<GenericValue extends boolean = boolean> extends DCommon.UnionToIntersection<Type<FundamentalType.TheBoolean, GenericValue, BooleanLiteralTypeDefinition> & DKind.Kind<typeof booleanLiteralTypeKind>> {
+export interface BooleanLiteralType<GenericValue extends boolean = boolean> extends DCommon.Forward<Type<FundamentalType.TheBoolean, GenericValue, BooleanLiteralTypeDefinition> & DKind.Kind<typeof booleanLiteralTypeKind>> {
 }
 export declare const BooleanLiteralType: <const GenericBoolean extends boolean>(value: GenericBoolean) => BooleanLiteralType<GenericBoolean>;

package/dist/dataStructure/type/defaults/date.d.ts

@@ -6,6 +6,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const dateTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/date-type", unknown>>;
 export interface DateTypeDefinition extends TypeDefinition {
 }
-export interface DateType extends DCommon.UnionToIntersection<Type<FundamentalType.TheDate, DChrono.TheDate, DateTypeDefinition> & DKind.Kind<typeof dateTypeKind>> {
+export interface DateType extends DCommon.Forward<Type<FundamentalType.TheDate, DChrono.TheDate, DateTypeDefinition> & DKind.Kind<typeof dateTypeKind>> {
 }
 export declare const DateType: () => DateType;

package/dist/dataStructure/type/defaults/null.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const nullTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/null-type", unknown>>;
 export interface NullTypeDefinition extends TypeDefinition {
 }
-export interface NullType extends DCommon.UnionToIntersection<Type<FundamentalType.TheNull, null, NullTypeDefinition> & DKind.Kind<typeof nullTypeKind>> {
+export interface NullType extends DCommon.Forward<Type<FundamentalType.TheNull, null, NullTypeDefinition> & DKind.Kind<typeof nullTypeKind>> {
 }
 export declare const NullType: () => NullType;

package/dist/dataStructure/type/defaults/number.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const numberTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-type", unknown>>;
 export interface NumberTypeDefinition extends TypeDefinition {
 }
-export interface NumberType extends DCommon.UnionToIntersection<Type<FundamentalType.TheNumber, number, NumberTypeDefinition> & DKind.Kind<typeof numberTypeKind>> {
+export interface NumberType extends DCommon.Forward<Type<FundamentalType.TheNumber, number, NumberTypeDefinition> & DKind.Kind<typeof numberTypeKind>> {
 }
 export declare const NumberType: () => NumberType;

package/dist/dataStructure/type/defaults/numberLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const numberLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface NumberLiteralTypeDefinition extends TypeDefinition {
     value: number;
 }
-export interface NumberLiteralType<GenericValue extends number = number> extends DCommon.UnionToIntersection<Type<FundamentalType.TheNumber, GenericValue, NumberLiteralTypeDefinition> & DKind.Kind<typeof numberLiteralTypeKind>> {
+export interface NumberLiteralType<GenericValue extends number = number> extends DCommon.Forward<Type<FundamentalType.TheNumber, GenericValue, NumberLiteralTypeDefinition> & DKind.Kind<typeof numberLiteralTypeKind>> {
 }
 export declare const NumberLiteralType: <const GenericNumber extends number>(value: GenericNumber) => NumberLiteralType<GenericNumber>;

package/dist/dataStructure/type/defaults/string.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const stringTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-type", unknown>>;
 export interface StringTypeDefinition extends TypeDefinition {
 }
-export interface StringType extends DCommon.UnionToIntersection<Type<FundamentalType.TheString, string, StringTypeDefinition> & DKind.Kind<typeof stringTypeKind>> {
+export interface StringType extends DCommon.Forward<Type<FundamentalType.TheString, string, StringTypeDefinition> & DKind.Kind<typeof stringTypeKind>> {
 }
 export declare const StringType: () => StringType;

package/dist/dataStructure/type/defaults/stringLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const stringLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface StringLiteralTypeDefinition extends TypeDefinition {
     value: string;
 }
-export interface StringLiteralType<GenericValue extends string = string> extends DCommon.UnionToIntersection<Type<FundamentalType.TheString, GenericValue, StringLiteralTypeDefinition> & DKind.Kind<typeof stringLiteralTypeKind>> {
+export interface StringLiteralType<GenericValue extends string = string> extends DCommon.Forward<Type<FundamentalType.TheString, GenericValue, StringLiteralTypeDefinition> & DKind.Kind<typeof stringLiteralTypeKind>> {
 }
 export declare const StringLiteralType: <const GenericString extends string>(value: GenericString) => StringLiteralType<GenericString>;

package/dist/dataStructure/type/defaults/time.d.ts

@@ -6,6 +6,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const timeTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-type", unknown>>;
 export interface TimeTypeDefinition extends TypeDefinition {
 }
-export interface TimeType extends DCommon.UnionToIntersection<Type<FundamentalType.TheTime, DChrono.TheTime, TimeTypeDefinition> & DKind.Kind<typeof timeTypeKind>> {
+export interface TimeType extends DCommon.Forward<Type<FundamentalType.TheTime, DChrono.TheTime, TimeTypeDefinition> & DKind.Kind<typeof timeTypeKind>> {
 }
 export declare const TimeType: () => TimeType;

package/dist/dataStructure/type/defaults/undefined.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const undefinedTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/undefined-type", unknown>>;
 export interface UndefinedTypeDefinition extends TypeDefinition {
 }
-export interface UndefinedType extends DCommon.UnionToIntersection<Type<FundamentalType.TheUndefined, undefined, UndefinedTypeDefinition> & DKind.Kind<typeof undefinedTypeKind>> {
+export interface UndefinedType extends DCommon.Forward<Type<FundamentalType.TheUndefined, undefined, UndefinedTypeDefinition> & DKind.Kind<typeof undefinedTypeKind>> {
 }
 export declare const UndefinedType: () => UndefinedType;

package/dist/dataStructure/type/identifier.d.ts

@@ -1,5 +1,7 @@
 import { Type } from './base';
+import { Types } from './types';
+import * as DKind from '../../kind';
 export declare const typeIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/date-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/null-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", bigint>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", boolean>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", null>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", number>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", string>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends GenericKindHandler extends DKind.Handler<DKind.Definition<string, unknown>> ? DKind.Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (GenericInput extends Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition> ? (import('..').BigintType extends infer T ? T extends import('..').BigintType ? T extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').BooleanType extends infer T_1 ? T_1 extends import('..').BooleanType ? T_1 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').DateType extends infer T_2 ? T_2 extends import('..').DateType ? T_2 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').NullType extends infer T_3 ? T_3 extends import('..').NullType ? T_3 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').NumberType extends infer T_4 ? T_4 extends import('..').NumberType ? T_4 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').StringType extends infer T_5 ? T_5 extends import('..').StringType ? T_5 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').TimeType extends infer T_6 ? T_6 extends import('..').TimeType ? T_6 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').UndefinedType extends infer T_7 ? T_7 extends import('..').UndefinedType ? T_7 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').BigintLiteralType<bigint> extends infer T_8 ? T_8 extends import('..').BigintLiteralType<bigint> ? T_8 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').BooleanLiteralType<boolean> extends infer T_9 ? T_9 extends import('..').BooleanLiteralType<boolean> ? T_9 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').NumberLiteralType<number> extends infer T_10 ? T_10 extends import('..').NumberLiteralType<number> ? T_10 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').StringLiteralType<string> extends infer T_11 ? T_11 extends import('..').StringLiteralType<string> ? T_11 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/date-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/null-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", bigint>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", boolean>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", null>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", number>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", string>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends GenericKindHandler extends DKind.Handler<DKind.Definition<string, unknown>> ? DKind.Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (GenericInput extends Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition> ? (import('..').BigintType extends infer T ? T extends import('..').BigintType ? T extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').BooleanType extends infer T_1 ? T_1 extends import('..').BooleanType ? T_1 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').DateType extends infer T_2 ? T_2 extends import('..').DateType ? T_2 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').NullType extends infer T_3 ? T_3 extends import('..').NullType ? T_3 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').NumberType extends infer T_4 ? T_4 extends import('..').NumberType ? T_4 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').StringType extends infer T_5 ? T_5 extends import('..').StringType ? T_5 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').TimeType extends infer T_6 ? T_6 extends import('..').TimeType ? T_6 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').UndefinedType extends infer T_7 ? T_7 extends import('..').UndefinedType ? T_7 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').BigintLiteralType<bigint> extends infer T_8 ? T_8 extends import('..').BigintLiteralType<bigint> ? T_8 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').BooleanLiteralType<boolean> extends infer T_9 ? T_9 extends import('..').BooleanLiteralType<boolean> ? T_9 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').NumberLiteralType<number> extends infer T_10 ? T_10 extends import('..').NumberLiteralType<number> ? T_10 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) | (import('..').StringLiteralType<string> extends infer T_11 ? T_11 extends import('..').StringLiteralType<string> ? T_11 extends GenericInput ? GenericInput & Types extends GenericGroupedKind ? GenericGroupedKind & GenericInput & Types : never : never : never : never) : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/index.cjs

@@ -15,6 +15,7 @@ const require_callThen = require("./common/callThen.cjs");
 const require_index$1 = require("./object/index.cjs");
 const require_clone = require("./common/clone.cjs");
 const require_index$2 = require("./common/constraint/cast/index.cjs");
+const require_remove = require("./common/constraint/remove.cjs");
 const require_detachObjectMethod = require("./common/detachObjectMethod.cjs");
 const require_enum = require("./common/enum.cjs");
 const require_equal = require("./common/equal.cjs");
@@ -286,6 +287,7 @@ exports.preparePipe = require_preparePipe.preparePipe;
 exports.promiseAll = require_promiseAll.promiseAll;
 exports.promiseObject = require_promiseObject.promiseObject;
 exports.queueKind = require_queue.queueKind;
+exports.removeConstraint = require_remove.removeConstraint;
 exports.shameOnYou = require_index$2.shameOnYou;
 exports.simpleClone = require_simpleClone.simpleClone;
 exports.stringToBytes = require_stringToBytes.stringToBytes;

package/dist/index.mjs

@@ -14,6 +14,7 @@ import { callThen } from "./common/callThen.mjs";
 import { object_exports } from "./object/index.mjs";
 import { clone } from "./common/clone.mjs";
 import { cast, shameOnYou } from "./common/constraint/cast/index.mjs";
+import { removeConstraint } from "./common/constraint/remove.mjs";
 import { detachObjectMethod } from "./common/detachObjectMethod.mjs";
 import { createEnum } from "./common/enum.mjs";
 import { equal } from "./common/equal.mjs";
@@ -67,4 +68,4 @@ import { pattern_exports } from "./pattern/index.mjs";
 import { invocation_exports } from "./invocation/index.mjs";
 import { path_exports } from "./path/index.mjs";
 import { printer_exports } from "./printer/index.mjs";
-export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/invocation/flow/base.d.ts

@@ -1,6 +1,6 @@
 import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult, UnwrapFlowControllerResult } from './controller';
-import { DKind } from '../../index.ts';
 import * as DCommon from '../../common';
+import type * as DKind from '../../kind';
 type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = GenericAccumulator extends [
     ...infer InferredRest,
     infer InferredLast

package/dist/invocation/flow/controller/defaults/aborter.cjs

@@ -1,5 +1,6 @@
 const require_parentClass = require("../../../../kind/parentClass.cjs");
 const require_create = require("../../../../either/left/create.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
 const require_kind = require("../../../kind.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/invocation/flow/controller/defaults/aborter.ts
@@ -11,14 +12,16 @@ var AbortErrorFlowController = class extends require_parentClass.parentClass(req
 		this.abortController = abortController;
 	}
 };
-const aborter = require_base.createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction) => {
+const aborter = require_base.createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
 	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : require_stringToMillisecond.stringToMillisecond(params.timeout);
 	return init(async (previousFunction) => {
 		const result = previousFunction();
 		if (require_base.flowControllerExitKind.has(result)) return result;
 		aborter?.abort(new AbortErrorFlowController(aborter));
 		const currentAborter = new AbortController();
 		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
 		try {
 			const abortResult = await theFunction(result, currentAborter);
 			if (currentAborter.signal.aborted === true) return exitFlow(require_create.left("signal-aborted", currentAborter.signal.reason));

package/dist/invocation/flow/controller/defaults/aborter.d.ts

@@ -1,14 +1,17 @@
 import { FlowController } from '../base';
-import type * as DCommon from '../../../../common';
+import * as DCommon from '../../../../common';
 import * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerAborterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-aborter", unknown>>;
-export interface FlowControllerAborter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<Awaited<GenericOutput> | DEither.Left<"signal-aborted", AbortErrorFlowController>>> & DKind.Kind<typeof flowControllerAborterKind>> {
+export interface FlowControllerAborter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<Awaited<GenericOutput> | DEither.Left<"signal-aborted", AbortErrorFlowController>>> & DKind.Kind<typeof flowControllerAborterKind>> {
 }
 declare const AbortErrorFlowController_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/abort-error-flow-controller", unknown>>, ErrorConstructor>;
 export declare class AbortErrorFlowController extends AbortErrorFlowController_base {
     abortController: AbortController;
     constructor(abortController: AbortController);
 }
-export declare const aborter: <GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: GenericInput, aborter: AbortController) => GenericOutput) => FlowControllerAborter<GenericInput, GenericOutput>;
+export interface FlowControllerAborterParams {
+    timeout?: DCommon.TimeInString;
+}
+export declare const aborter: <GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: GenericInput, aborter: AbortController) => GenericOutput, params?: FlowControllerAborterParams) => FlowControllerAborter<GenericInput, GenericOutput>;
 export {};

package/dist/invocation/flow/controller/defaults/aborter.mjs

@@ -1,5 +1,6 @@
 import { parentClass } from "../../../../kind/parentClass.mjs";
 import { left } from "../../../../either/left/create.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
 import { createKind } from "../../../kind.mjs";
 import { createFlowController, flowControllerExitKind } from "../base.mjs";
 //#region scripts/invocation/flow/controller/defaults/aborter.ts
@@ -11,14 +12,16 @@ var AbortErrorFlowController = class extends parentClass(createKind("abort-error
 		this.abortController = abortController;
 	}
 };
-const aborter = createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction) => {
+const aborter = createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
 	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : stringToMillisecond(params.timeout);
 	return init(async (previousFunction) => {
 		const result = previousFunction();
 		if (flowControllerExitKind.has(result)) return result;
 		aborter?.abort(new AbortErrorFlowController(aborter));
 		const currentAborter = new AbortController();
 		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
 		try {
 			const abortResult = await theFunction(result, currentAborter);
 			if (currentAborter.signal.aborted === true) return exitFlow(left("signal-aborted", currentAborter.signal.reason));

package/dist/invocation/flow/controller/defaults/debounce.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerDebounceKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-debounce", unknown>>;
-export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
+export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
 }
 export declare const debounce: <GenericInput extends unknown = unknown>(debounce: DCommon.TimeInString) => FlowControllerDebounce<GenericInput>;

package/dist/invocation/flow/controller/defaults/filter.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerFilterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-filter", unknown>>;
-export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, DCommon.SplitPromise<GenericOutput> extends infer InferredOutput ? InferredOutput extends unknown ? Awaited<InferredOutput> extends infer InferredAwaited ? (InferredAwaited extends DEither.Left ? FlowControllerExit<InferredAwaited> : InferredAwaited extends DEither.Right ? DEither.GetValue<InferredAwaited> : InferredAwaited) extends infer InferredResult ? InferredOutput extends Promise<unknown> ? Promise<InferredResult> : InferredResult : never : never : never : never> & DKind.Kind<typeof flowControllerFilterKind>> {
+export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, DCommon.SplitPromise<GenericOutput> extends infer InferredOutput ? InferredOutput extends unknown ? Awaited<InferredOutput> extends infer InferredAwaited ? (InferredAwaited extends DEither.Left ? FlowControllerExit<InferredAwaited> : InferredAwaited extends DEither.Right ? DEither.GetValue<InferredAwaited> : InferredAwaited) extends infer InferredResult ? InferredOutput extends Promise<unknown> ? Promise<InferredResult> : InferredResult : never : never : never : never> & DKind.Kind<typeof flowControllerFilterKind>> {
 }
 export declare const filter: <GenericInput extends unknown, GenericOutput extends unknown>(filterFunction: (input: GenericInput) => GenericOutput) => FlowControllerFilter<GenericInput, GenericOutput>;

package/dist/invocation/flow/controller/defaults/retry.d.ts

@@ -2,7 +2,7 @@ import { FlowController } from '../base';
 import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 export declare const flowControllerRetryKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-retry", unknown>>;
-export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
+export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
 }
 export interface RetryParams {
     times?: number;

package/dist/invocation/flow/controller/defaults/throttling.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerThrottlingKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-throttling", unknown>>;
-export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
+export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
 }
 export declare const throttling: <GenericInput extends unknown = unknown>(throttling: DCommon.TimeInString) => FlowControllerThrottling<GenericInput>;

package/dist/invocation/flow/controller/defaults/timeout.d.ts

@@ -2,6 +2,6 @@ import { FlowController } from '../base';
 import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 export declare const flowControllerTimeoutKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-timeout", unknown>>;
-export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
+export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
 }
 export declare const timeout: <GenericInput extends unknown = unknown>(timeout: DCommon.TimeInString) => FlowControllerTimeout<GenericInput>;

package/dist/kind/createIdentifier.d.ts

@@ -2,6 +2,6 @@ import { Kind, Handler } from './base';
 import { GetHandler } from './types';
 import type * as DCommon from '../common';
 export declare function createKindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent>(): {
-    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
-    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is ((GenericInput extends GenericParent ? GenericChildren extends GenericInput ? GenericChildren extends GenericGroupedKind ? GenericChildren : never : never : never) | Extract<GenericInput, GenericGroupedKind>);
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is ((GenericInput extends GenericParent ? GenericChildren extends GenericInput ? GenericChildren extends GenericGroupedKind ? GenericChildren : never : never : never) | Extract<GenericInput, GenericGroupedKind>);
 };

package/dist/modeling/entity/base.d.ts

@@ -1,4 +1,3 @@
-import { Codecs, EncodedValue } from '../../dataStructure/common';
 import { NewType, NewTypeMap } from '../newType';
 import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
@@ -10,9 +9,9 @@ declare module '../../dataStructure' {
     }
 }
 declare module '../../dataStructure/common' {
-    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends Codecs> {
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
         entity: GenericValue extends Entity<infer InferredName> ? (Entity<InferredName> & {
-            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: EncodedValue<GenericValue[Prop], GenericCodecs>;
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
         }) : never;
     }
 }
@@ -34,7 +33,7 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
-export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.UnionToIntersection<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
+export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.Forward<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
     readonly name: GenericName;
     "new"<GenericNewProperties extends GenericProperties>(properties: GenericNewProperties): (Entity<GenericName> & GenericNewProperties);
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);

package/dist/modeling/newType/base.d.ts

@@ -25,7 +25,7 @@ export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends rea
     readonly newTypeConstraints: GenericNewTypeConstraint;
 }
 export type ComputeNewType<GenericName extends string, GenericValue extends unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[], GenericIntersectionConstraintValue = DDataStructure.ConstraintValue<DArray.Unwrap<GenericNewTypeConstraint>>, GenericClearValue = DCommon.NeverCoalescing<DCommon.RemoveConstraint<GenericIntersectionConstraintValue>, unknown>> = (GenericValue & GenericClearValue & NewType<GenericName, GenericIntersectionConstraintValue extends (GenericClearValue & infer InferredConstraint extends DCommon.BaseConstraint) ? InferredConstraint : never>);
-export interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
+export interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.Forward<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
     readonly name: GenericName;
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);

package/dist/modeling/taggedObject/base.d.ts

@@ -1,4 +1,3 @@
-import { Codecs, EncodedValue } from '../../dataStructure/common';
 import type * as DKind from '../../kind';
 import type * as DCommon from '../../common';
 import * as DDataStructure from '../../dataStructure';
@@ -8,9 +7,9 @@ declare module '../../dataStructure' {
     }
 }
 declare module '../../dataStructure/common' {
-    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends Codecs> {
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
         taggedObject: GenericValue extends ObjectTag<infer InferredName> ? (ObjectTag<InferredName> & {
-            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: EncodedValue<GenericValue[Prop], GenericCodecs>;
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
         }) : never;
     }
 }
@@ -26,7 +25,7 @@ export declare const taggedObjectStructureKind: DKind.Handler<DKind.Definition<"
 export interface TaggedObjectStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DDataStructure.ObjectStructure;
 }
-export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.UnionToIntersection<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
+export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
 }
 export declare const TaggedObjectStructure: <GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape) => TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;

package/dist/string/isUrl.cjs

@@ -1,16 +1,7 @@
 //#region scripts/string/isUrl.ts
-const regexRemoveDote = /:$/;
-function isUrl(string, params) {
+function isUrl(string) {
 	try {
-		const url = new URL(string);
-		if (params?.hostname) {
-			params.hostname.lastIndex = 0;
-			if (!params.hostname.test(url.hostname)) return false;
-		}
-		if (params?.protocol) {
-			params.protocol.lastIndex = 0;
-			if (!params.protocol.test(url.protocol.replace(regexRemoveDote, ""))) return false;
-		}
+		new URL(string);
 		return true;
 	} catch {
 		return false;

package/dist/string/isUrl.d.ts

@@ -1,6 +1,2 @@
 import { Url } from './constraints';
-export interface IsUrlParams {
-    hostname?: RegExp;
-    protocol?: RegExp;
-}
-export declare function isUrl<GenericValue extends string>(string: GenericValue, params?: IsUrlParams): string is GenericValue & Url;
+export declare function isUrl<GenericValue extends string>(string: GenericValue): string is GenericValue & Url;

package/dist/string/isUrl.mjs

@@ -1,16 +1,7 @@
 //#region scripts/string/isUrl.ts
-const regexRemoveDote = /:$/;
-function isUrl(string, params) {
+function isUrl(string) {
 	try {
-		const url = new URL(string);
-		if (params?.hostname) {
-			params.hostname.lastIndex = 0;
-			if (!params.hostname.test(url.hostname)) return false;
-		}
-		if (params?.protocol) {
-			params.protocol.lastIndex = 0;
-			if (!params.protocol.test(url.protocol.replace(regexRemoveDote, ""))) return false;
-		}
+		new URL(string);
 		return true;
 	} catch {
 		return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.1-beta.3",
   "license": "MIT",
   "type": "module",
   "author": {