@duplojs/lang 0.0.1-beta.1 → 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/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<"@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<"@DuplojsLangModeling/entity-name-structure", unknown>> | 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').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('..').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('..').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> | Extract<import('../../modeling').EntityNameStructure, 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/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<"@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<"@DuplojsLangModeling/entity-name-structure", unknown>> | 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').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('..').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('..').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> | Extract<import('../../modeling').EntityNameStructure, 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/structure/types/constraintsValue.d.ts

@@ -1,6 +1,6 @@
 import { ConstraintValue, Constraint } from '../../constraint';
 import type * as DCommon from '../../../common';
-export type StructureConstraintsValue<GenericConstraints extends Constraint> = DCommon.NeverCoalescing<Extract<DCommon.UnionToIntersection<GenericConstraints extends Constraint ? {
+export type StructureConstraintsValue<GenericConstraints extends Constraint> = DCommon.IsNever<GenericConstraints> extends true ? unknown : DCommon.NeverCoalescing<Extract<DCommon.UnionToIntersection<GenericConstraints extends Constraint ? {
     value: ConstraintValue<GenericConstraints>;
 } : never>, {
     value: unknown;

package/dist/dataStructure/structure/types/structures.d.ts

@@ -1,5 +1,5 @@
 import { Structure } from '../base';
-import { ObjectStructure, ArrayStructure, LazyStructure, RecordStructure, UnionStructure, TypeStructure } from '../defaults';
+import { ObjectStructure, ArrayStructure, LazyStructure, RecordStructure, UnionStructure, TypeStructure, NonEncodableStringStructure } from '../defaults';
 export interface StructuresStore {
     base: Structure;
     array: ArrayStructure;
@@ -8,5 +8,6 @@ export interface StructuresStore {
     record: RecordStructure;
     union: UnionStructure;
     type: TypeStructure;
+    nonEncodableString: NonEncodableStringStructure;
 }
 export type Structures = Extract<StructuresStore[keyof StructuresStore], Structure>;

package/dist/dataStructure/structure/types/value.d.ts

@@ -2,4 +2,4 @@ import { structureKind, Structure } from '../base';
 import { StructureConstraintsValue } from './constraintsValue';
 import type * as DKind from '../../../kind';
 export type StructureValue<GenericStructure extends Structure> = DKind.GetValue<typeof structureKind, GenericStructure>;
-export type StructureInitialValue<GenericStructure extends Structure> = GenericStructure extends Structure<infer InferredValue> ? InferredValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : InferredValue : never;
+export type StructureInitialValue<GenericStructure extends Structure, GenericStructureValue = StructureValue<GenericStructure>> = GenericStructureValue extends unknown ? GenericStructureValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : GenericStructureValue : never;

package/dist/dataStructure/type/base.cjs

@@ -1,20 +1,33 @@
 const require_callThen = require("../../common/callThen.cjs");
+const require_simpleClone = require("../../common/simpleClone.cjs");
 const require_kind = require("../kind.cjs");
 const require_resultSymbol = require("../common/resultSymbol.cjs");
 //#region scripts/dataStructure/type/base.ts
 const typeKind = require_kind.createKind("type");
 function createType(fundamentalType, kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
+			fundamentalType,
 			definition,
-			executeCheck: (data, errorHandler) => require_callThen.callThen(self.fundamentalType.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeCheck(self, data, errorHandler)),
+			executeCheck: (data) => require_callThen.callThen(self.fundamentalType.executeCheck(data), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeCheck(self, data)),
 			isAsynchronous: () => isAsynchronous(self),
-			fundamentalType,
+			clone: () => init(require_simpleClone.simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[typeKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 exports.createType = createType;

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

@@ -1,18 +1,22 @@
 import { FundamentalType, FundamentalTypeValue } from '../fundamentalType';
-import { ErrorSymbol, GetErrorHandler, SuccessSymbol } from '../common';
+import { ErrorSymbol, SuccessSymbol } from '../common';
 import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 export declare const typeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", unknown>>;
 export interface TypeDefinition {
+    readonly message?: string;
 }
 export interface Type<GenericFundamentalType extends FundamentalType = FundamentalType, GenericValue extends FundamentalTypeValue<GenericFundamentalType> = FundamentalTypeValue<GenericFundamentalType>, GenericDefinition extends TypeDefinition = TypeDefinition> extends DKind.Kind<typeof typeKind, GenericValue> {
     readonly fundamentalType: GenericFundamentalType;
     readonly definition: GenericDefinition;
-    executeCheck(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(data: unknown): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(): boolean;
+    clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateTypeInitParams<GenericType extends Type = Type, GenericFundamentalType extends FundamentalType = FundamentalType> {
-    executeCheck(self: GenericType, data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(self: GenericType, data: FundamentalTypeValue<GenericFundamentalType>): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericType): boolean;
 }
 export interface CreateTypeConstructorParams<GenericFundamentalType extends FundamentalType = FundamentalType, GenericKindHandler extends DKind.Handler = DKind.Handler> {

package/dist/dataStructure/type/base.mjs

@@ -1,20 +1,33 @@
 import { callThen } from "../../common/callThen.mjs";
+import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 import { ErrorSymbol } from "../common/resultSymbol.mjs";
 //#region scripts/dataStructure/type/base.ts
 const typeKind = createKind("type");
 function createType(fundamentalType, kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
+			fundamentalType,
 			definition,
-			executeCheck: (data, errorHandler) => callThen(self.fundamentalType.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeCheck(self, data, errorHandler)),
+			executeCheck: (data) => callThen(self.fundamentalType.executeCheck(data), (result) => result === ErrorSymbol ? ErrorSymbol : executeCheck(self, data)),
 			isAsynchronous: () => isAsynchronous(self),
-			fundamentalType,
+			clone: () => init(simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[typeKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 export { createType, typeKind };

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.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/bigintLiteral.ts
 const bigintLiteralTypeKind = require_kind.createKind("bigint-literal-type");
 const BigintLiteralType = require_base.createType(require_bigint.TheBigint, bigintLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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/bigintLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/bigintLiteral.ts
 const bigintLiteralTypeKind = createKind("bigint-literal-type");
 const BigintLiteralType = createType(TheBigint, bigintLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/booleanLiteral.ts
 const booleanLiteralTypeKind = require_kind.createKind("boolean-literal-type");
 const BooleanLiteralType = require_base.createType(require_boolean.TheBoolean, booleanLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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/booleanLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/booleanLiteral.ts
 const booleanLiteralTypeKind = createKind("boolean-literal-type");
 const BooleanLiteralType = createType(TheBoolean, booleanLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/numberLiteral.ts
 const numberLiteralTypeKind = require_kind.createKind("number-literal-type");
 const NumberLiteralType = require_base.createType(require_number.TheNumber, numberLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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/numberLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/numberLiteral.ts
 const numberLiteralTypeKind = createKind("number-literal-type");
 const NumberLiteralType = createType(TheNumber, numberLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/stringLiteral.ts
 const stringLiteralTypeKind = require_kind.createKind("string-literal-type");
 const StringLiteralType = require_base.createType(require_string.TheString, stringLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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/stringLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/stringLiteral.ts
 const stringLiteralTypeKind = createKind("string-literal-type");
 const StringLiteralType = createType(TheString, stringLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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<symbol, 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<symbol, 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/generator/asyncChunk.d.ts

@@ -1,2 +1,3 @@
-export declare function asyncChunk<const GenericItem extends unknown>(size: number): (iterator: AsyncIterable<GenericItem>) => AsyncGenerator<GenericItem[], unknown, unknown>;
-export declare function asyncChunk<const GenericItem extends unknown>(iterator: AsyncIterable<GenericItem>, size: number): AsyncGenerator<GenericItem[], unknown, unknown>;
+import type * as DArray from '../array';
+export declare function asyncChunk<const GenericItem extends unknown, GenericSize extends number>(size: GenericSize): (iterator: AsyncIterable<GenericItem>) => AsyncGenerator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;
+export declare function asyncChunk<const GenericItem extends unknown, GenericSize extends number>(iterator: AsyncIterable<GenericItem>, size: GenericSize): AsyncGenerator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;

package/dist/generator/chunk.d.ts

@@ -1,2 +1,3 @@
-export declare function chunk<const GenericItem extends unknown>(size: number): (iterator: Iterable<GenericItem>) => Generator<GenericItem[], unknown, unknown>;
-export declare function chunk<const GenericItem extends unknown>(iterator: Iterable<GenericItem>, size: number): Generator<GenericItem[], unknown, unknown>;
+import type * as DArray from '../array';
+export declare function chunk<const GenericItem extends unknown, GenericSize extends number>(size: GenericSize): (iterator: Iterable<GenericItem>) => Generator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;
+export declare function chunk<const GenericItem extends unknown, GenericSize extends number>(iterator: Iterable<GenericItem>, size: GenericSize): Generator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;

package/dist/generator/types/flat.d.ts

@@ -1,3 +1,3 @@
 import type * as DCommon from '../../common';
-export type FlatIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
-export type FlatAsyncIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue extends AsyncIterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
+export type FlatIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends string ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
+export type FlatAsyncIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends string ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue extends AsyncIterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;

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,12 +1,17 @@
-import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult } from './controller';
-import { DKind } from '../../index.ts';
+import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult, UnwrapFlowControllerResult } from './controller';
 import * as DCommon from '../../common';
+import type * as DKind from '../../kind';
 type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = GenericAccumulator extends [
     ...infer InferredRest,
     infer InferredLast
 ] ? InferredLast extends FlowControllerResult<infer InferredFlowControllerResult> ? Exclude<Awaited<InferredFlowControllerResult>, FlowControllerPreviousFunctionResult | FlowControllerExit> extends infer InferredOutputValue ? DCommon.HasSomething<InferredOutputValue> extends true ? InferredOutputValue : InferredRest extends DCommon.AnyTuple ? ComputeLastUsableValue<InferredRest> : never : never : InferredLast : never;
 type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>) => GenericOutput;
-type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (GenericAccumulator[number] extends infer InferredPipeResult ? InferredPipeResult extends FlowControllerResult<infer InferredResult> ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : never : never : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, Promise<any>> extends true ? Promise<Awaited<InferredResult>> : InferredResult : never, any>;
+type IsMaybePromise<GenericAccumulator extends DCommon.AnyTuple> = {
+    [Index in keyof GenericAccumulator]: UnwrapFlowControllerResult<GenericAccumulator[Index]> extends infer InferredResult ? DCommon.IsExtends<InferredResult, Promise<unknown>> extends true ? false : DCommon.ContainExtends<InferredResult, Promise<any>> : never;
+}[number] extends false ? false : true;
+type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (UnwrapFlowControllerResult<GenericAccumulator[number]> extends infer InferredResult ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : InferredResult extends Promise<unknown> ? Promise<never> : never : never)) extends infer InferredResult ? DCommon.Or<[
+    DCommon.ContainExtends<InferredResult, Promise<any>>
+]> extends true ? IsMaybePromise<GenericAccumulator> extends true ? DCommon.MaybePromise<Awaited<InferredResult>> : Promise<Awaited<InferredResult>> : InferredResult : never, any>;
 export declare function flow<const GenericInput extends unknown, const GenericOutput1 extends unknown>(pipe1: Pipe<[
     GenericInput
 ], GenericOutput1>): (input: GenericInput) => DCommon.BreakGenericLink<Extract<ComputeTypeOutput<[

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

@@ -11,6 +11,7 @@ export type FlowControllerPreviousFunctionResult = DCommon.MaybePromise<(DCommon
 export interface FlowControllerResult<GenericResult extends unknown> {
     readonly [FlowControllerResultSymbol]: GenericResult;
 }
+export type UnwrapFlowControllerResult<GenericValue extends unknown> = GenericValue extends FlowControllerResult<infer InferredResult> ? InferredResult : GenericValue;
 export interface FlowController<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof flowControllerKind> {
     (this: never, input: GenericInput): FlowControllerResult<GenericOutput>;
     exec(previousFunction: () => FlowControllerPreviousFunctionResult): (FlowControllerPreviousFunctionResult | GenericOutput | DCommon.MergePromise<FlowControllerPreviousFunctionResult | GenericOutput>);