@duplojs/lang 0.0.1-beta.8 → 0.1.0-beta.1

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

@@ -3,6 +3,7 @@ import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import * as DDataStructure from '../../dataStructure';
 import * as DEither from '../../either';
+import * as DObject from '../../object';
 declare module '../../dataStructure' {
     interface StructuresStore {
         entity: EntityStructure;
@@ -33,14 +34,21 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: EntityMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
-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>> {
+export type EntityUpdate<GenericEntity extends Entity, GenericNewProperties extends object> = Extract<(Entity<GetEntityName<GenericEntity>> & DCommon.SimplifyTopLevel<DKind.Remove<GenericEntity> extends infer InferredProperties ? {
+    [Prop in keyof InferredProperties]: Prop extends keyof GenericNewProperties ? GenericNewProperties[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? InferredProperties[Prop] : InferredNewValue : never : InferredProperties[Prop];
+} : never>), any>;
+type ForbiddenMoreKey<GenericProperties extends Record<string, unknown>, GenericNewProperties extends Record<string, unknown>> = DObject.ForbiddenKey<GenericNewProperties, Extract<Exclude<keyof GenericNewProperties, keyof GenericProperties>, string>>;
+export interface EntityStructure<out GenericName extends string = string, out 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>);
-    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>);
-    map(data: EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    "new"<GenericNewProperties extends GenericProperties>(properties: (GenericNewProperties & ForbiddenMoreKey<GenericProperties, GenericNewProperties>)): (Entity<GenericName> & DCommon.SimplifyTopLevel<Readonly<GenericNewProperties>>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>) => (DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>): (DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: EntityMap<GenericProperties>): (DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>) => Promise<DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>): Promise<DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: EntityMap<GenericProperties>): Promise<DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"map-error", DDataStructure.Error>>;
+    update<GenericInputEntity extends (Entity<GenericName> & GenericProperties), const GenericPayload extends Partial<GenericProperties>>(update: GenericPayload): (input: GenericInputEntity) => EntityUpdate<GenericInputEntity, GenericPayload>;
+    update<GenericInputEntity extends (Entity<GenericName> & GenericProperties), const GenericPayload extends Partial<GenericProperties>>(input: GenericInputEntity, update: GenericPayload): EntityUpdate<GenericInputEntity, GenericPayload>;
 }
 export declare const EntityStructure: <GenericName extends string, GenericShape extends DDataStructure.ShapeObjectStructure, const GenericProperties extends DDataStructure.ShapeObjectStructureValue<GenericShape>>(name: GenericName, shape: () => GenericShape) => EntityStructure<GenericName, GenericProperties>;
+export {};

package/dist/modeling/entity/base.mjs

@@ -4,7 +4,7 @@ import { right } from "../../either/right/create.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { memo } from "../../common/memo.mjs";
 import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { ErrorPromise, createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
@@ -22,6 +22,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 	executeCheck: (self, data, errorHandler) => self.definition.inner.value.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.value.isAsynchronous()
 }, {
 	name,
@@ -40,7 +41,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 			...data,
 			[entityKind.runTimeKey]: name
 		} : data, errorHandler);
-		if (result instanceof Promise) return left("async-error", void 0);
+		if (result instanceof Promise) return left("async-error", new ErrorPromise());
 		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", result);
 	},
@@ -51,7 +52,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 			[entityKind.runTimeKey]: name
 		} : data;
 		const result = self.executeCheck(formattedData, errorHandler);
-		if (result instanceof Promise) return left("async-error", void 0);
+		if (result instanceof Promise) return left("async-error", new ErrorPromise());
 		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
 	},
@@ -71,7 +72,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		const formattedData = isSimple(data) ? {
 			...data,
@@ -79,7 +80,17 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 		} : data;
 		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
-	})
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, update] = args;
+		const updatedEntity = { [entityKind.runTimeKey]: name };
+		for (const key of self.definition.inner.value.definition.keys) updatedEntity[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedEntity;
+	}
 }));
 //#endregion
 export { EntityStructure, entityKind, entityStructureKind };

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

@@ -1,15 +1,13 @@
 import { Entity, EntityStructure } from './base';
 import { NewType } from '../newType';
+import { ObjectTag } from '../taggedObject';
 import type * as DCommon from '../../common';
 import type * as DDataStructure from '../../dataStructure';
 import type * as DString from '../../string';
-export type ForbiddenMissingNewTypeInEntityShape<GenericValue extends unknown, GenericPath extends readonly string[] = readonly []> = GenericValue extends NewType ? never : GenericValue extends object ? DCommon.Or<[
-    DCommon.IsExtends<GenericValue, readonly any[]>,
-    DCommon.And<[
-        DCommon.IsExtends<keyof GenericValue, string>,
-        DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericValue[keyof GenericValue]>>
-    ]>
+export type ForbiddenMissingNewTypeInEntityShape<GenericValue extends unknown, GenericPath extends readonly string[] = readonly []> = GenericValue extends (ObjectTag | NewType | null | undefined | Entity) ? never : GenericValue extends readonly (infer InferredElement)[] ? ForbiddenMissingNewTypeInEntityShape<InferredElement, readonly [...GenericPath, "[number]"]> : GenericValue extends object ? DCommon.And<[
+    DCommon.IsExtends<keyof GenericValue, string>,
+    DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericValue[keyof GenericValue]>>
 ]> extends true ? {
-    [Prop in keyof GenericValue]: ForbiddenMissingNewTypeInEntityShape<GenericValue[Prop], readonly [...GenericPath, `${Extract<Prop, string | number>}`]>;
-}[keyof GenericValue] : GenericValue extends Entity ? never : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath>}' is not a NewType.`> : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath>}' is not a NewType.`>;
+    [Prop in keyof GenericValue]-?: ForbiddenMissingNewTypeInEntityShape<GenericValue[Prop], readonly [...GenericPath, `${Extract<Prop, string | number>}`]>;
+}[keyof GenericValue] : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath, ".">}' is not a NewType.`> : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath, ".">}' is not a NewType.`>;
 export declare function createEntity<GenericName extends Capitalize<string>, GenericShape extends DDataStructure.ShapeObjectStructure>(name: GenericName, shape: () => (GenericShape & DCommon.NeverCoalescing<ForbiddenMissingNewTypeInEntityShape<DDataStructure.ShapeObjectStructureValue<GenericShape>>, unknown>)): EntityStructure<GenericName, DDataStructure.ShapeObjectStructureValue<GenericShape & DCommon.NeverCoalescing<ForbiddenMissingNewTypeInEntityShape<DDataStructure.ShapeObjectStructureValue<GenericShape>, readonly []>, unknown>>>;

package/dist/modeling/entity/namespace.cjs

@@ -1,7 +1,6 @@
 const require_kind = require("../kind.cjs");
 const require_helper = require("./helper.cjs");
 const require_helper$1 = require("../newType/helper.cjs");
-const require_base = require("../flag/base.cjs");
 //#region scripts/modeling/entity/namespace.ts
 const namespaceKind = require_kind.createKind("namespace");
 function createEntityNamespace(entityName) {
@@ -9,7 +8,6 @@ function createEntityNamespace(entityName) {
 		name: entityName,
 		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => require_helper.createEntity(entityName, shape),
-		createFlag: (entityStructure, name, valueStructure) => require_base.createFlag(entityStructure, `${entityName}${name}`, valueStructure),
 		[namespaceKind.runTimeKey]: null
 	};
 }

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

@@ -1,7 +1,6 @@
 import { ForbiddenTopLevelNewType, NewTypeStructure } from '../newType';
 import { ForbiddenMissingNewTypeInEntityShape } from './helper';
 import { EntityStructure } from './base';
-import { FlagHandler } from '../flag';
 import type * as DCommon from '../../common';
 import type * as DDataStructure from '../../dataStructure';
 import type * as DKind from '../../kind';
@@ -10,6 +9,5 @@ export interface EntityNamespace<GenericEntityName extends Capitalize<string> =
     readonly name: GenericEntityName;
     createNewType<GenericName extends Capitalize<string>, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[] = readonly []>(name: (GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>), structure: GenericStructure, newTypeConstraints?: GenericNewTypeConstraint): NewTypeStructure<`${GenericEntityName}${GenericName}`, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;
     createEntity<GenericShape extends DDataStructure.ShapeObjectStructure>(shape: () => (GenericShape & DCommon.NeverCoalescing<ForbiddenMissingNewTypeInEntityShape<DDataStructure.ShapeObjectStructureValue<GenericShape>>, unknown>)): EntityStructure<GenericEntityName, DDataStructure.ShapeObjectStructureValue<GenericShape>>;
-    createFlag<GenericEntityStructure extends EntityStructure<GenericEntityName>, GenericName extends Capitalize<string>, GenericValueStructure extends DDataStructure.Structure>(entityStructure: GenericEntityStructure, name: GenericName, valueStructure: GenericValueStructure): FlagHandler<DDataStructure.StructureValue<GenericEntityStructure>, `${GenericEntityName}${GenericName}`, DDataStructure.StructureValue<GenericValueStructure>>;
 }
 export declare function createEntityNamespace<GenericName extends Capitalize<string>>(entityName: GenericName): EntityNamespace<GenericName>;

package/dist/modeling/entity/namespace.mjs

@@ -1,7 +1,6 @@
 import { createKind } from "../kind.mjs";
 import { createEntity } from "./helper.mjs";
 import { createNewType } from "../newType/helper.mjs";
-import { createFlag } from "../flag/base.mjs";
 //#region scripts/modeling/entity/namespace.ts
 const namespaceKind = createKind("namespace");
 function createEntityNamespace(entityName) {
@@ -9,7 +8,6 @@ function createEntityNamespace(entityName) {
 		name: entityName,
 		createNewType: (name, structure, newTypeConstraints = []) => createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => createEntity(entityName, shape),
-		createFlag: (entityStructure, name, valueStructure) => createFlag(entityStructure, `${entityName}${name}`, valueStructure),
 		[namespaceKind.runTimeKey]: null
 	};
 }

package/dist/modeling/fact/base.cjs

@@ -0,0 +1,36 @@
+const require_create = require("../../either/right/create.cjs");
+const require_kind = require("../kind.cjs");
+//#region scripts/modeling/fact/base.ts
+const factKind = require_kind.createKind("fact");
+const factHandlerKind = require_kind.createKind("fact-handler");
+function createFact(name) {
+	function applyFact(...args) {
+		if (args.length === 1) {
+			const [payload] = args;
+			return (entity) => applyFact(entity, payload);
+		}
+		const [entity, payload] = args;
+		const entityWithFact = {
+			...entity,
+			[factKind.runTimeKey]: {
+				name,
+				payload
+			}
+		};
+		return require_create.right(`fact-result-${name}`, entityWithFact);
+	}
+	return (createRun) => ({
+		name,
+		run: createRun({ applyFact }),
+		getPayload(entity) {
+			return factKind.getValue(entity).payload;
+		},
+		has(entity) {
+			return factKind.has(entity) && factKind.getValue(entity).name === name;
+		},
+		[factHandlerKind.runTimeKey]: null
+	});
+}
+//#endregion
+exports.createFact = createFact;
+exports.factKind = factKind;

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

@@ -0,0 +1,29 @@
+import { EntityStructure, Entity } from '../entity';
+import type * as DCommon from '../../common';
+import type * as DKind from '../../kind';
+import type * as DDataStructure from '../../dataStructure';
+import * as DEither from '../../either';
+export interface FactValue<GenericName extends string = string, GenericPayload extends unknown = unknown> {
+    name: GenericName;
+    payload: GenericPayload;
+}
+export declare const factKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/fact", FactValue<string, unknown>>>;
+export interface Fact<GenericName extends Capitalize<string> = Capitalize<string>, GenericValue extends unknown = unknown> extends DKind.Kind<typeof factKind, FactValue<GenericName, GenericValue>> {
+}
+export type GetFactName<GenericHandler extends Fact> = GenericHandler extends Fact<infer InferredName extends Capitalize<string>> ? InferredName : never;
+export type GetFactPayload<GenericHandler extends Fact> = GenericHandler extends Fact<any, infer InferredPayload extends object> ? InferredPayload : never;
+export type FactRun<GenericName extends string = string> = DCommon.AnyFunction<any[], DEither.Left | DEither.Right<`fact-result-${GenericName}`, unknown>>;
+declare const factHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/fact-handler", unknown>>;
+export interface FactHandler<GenericName extends Capitalize<string> = Capitalize<string>, GenericEntity extends Entity = Entity, GenericPayload extends object = object, GenericRun extends FactRun<GenericName> = FactRun<GenericName>> extends DKind.Kind<typeof factHandlerKind> {
+    readonly name: GenericName;
+    run: GenericRun;
+    getPayload<GenericInputEntity extends Fact<GenericName, GenericPayload>>(entity: GenericInputEntity): DKind.GetValue<typeof factKind, GenericInputEntity>["payload"];
+    has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): entity is Extract<GenericInputEntity, Fact<GenericName>>;
+}
+type RemoveFact<GenericEntity extends Entity> = GenericEntity extends Fact<infer InferredName, infer InferredValue> ? GenericEntity extends (infer InferredEntity & Fact<InferredName, InferredValue>) ? InferredEntity : GenericEntity : GenericEntity;
+export interface CreateFactConstructorParams<GenericName extends Capitalize<string> = Capitalize<string>, GenericEntity extends Entity = Entity, GenericPayload extends object = object> {
+    applyFact<GenericInputEntity extends GenericEntity, GenericInputPayload extends GenericPayload>(payload: GenericInputPayload): (entity: GenericInputEntity) => DEither.Right<`fact-result-${GenericName}`, RemoveFact<GenericInputEntity> & Fact<GenericName, GenericInputPayload>>;
+    applyFact<GenericInputEntity extends GenericEntity, GenericInputPayload extends GenericPayload>(entity: GenericInputEntity, payload: GenericInputPayload): DEither.Right<`fact-result-${GenericName}`, RemoveFact<GenericInputEntity> & Fact<GenericName, GenericInputPayload>>;
+}
+export declare function createFact<GenericFact extends Fact, GenericEntityStructure extends EntityStructure>(name: GetFactName<GenericFact>): <GenericRun extends FactRun<GetFactName<GenericFact>>>(createRun: (params: CreateFactConstructorParams<GetFactName<GenericFact>, DDataStructure.StructureValue<GenericEntityStructure>, GetFactPayload<GenericFact>>) => GenericRun) => FactHandler<GetFactName<GenericFact>, DDataStructure.StructureValue<GenericEntityStructure>, GetFactPayload<GenericFact>, GenericRun>;
+export {};

package/dist/modeling/fact/base.mjs

@@ -0,0 +1,35 @@
+import { right } from "../../either/right/create.mjs";
+import { createKind } from "../kind.mjs";
+//#region scripts/modeling/fact/base.ts
+const factKind = createKind("fact");
+const factHandlerKind = createKind("fact-handler");
+function createFact(name) {
+	function applyFact(...args) {
+		if (args.length === 1) {
+			const [payload] = args;
+			return (entity) => applyFact(entity, payload);
+		}
+		const [entity, payload] = args;
+		const entityWithFact = {
+			...entity,
+			[factKind.runTimeKey]: {
+				name,
+				payload
+			}
+		};
+		return right(`fact-result-${name}`, entityWithFact);
+	}
+	return (createRun) => ({
+		name,
+		run: createRun({ applyFact }),
+		getPayload(entity) {
+			return factKind.getValue(entity).payload;
+		},
+		has(entity) {
+			return factKind.has(entity) && factKind.getValue(entity).name === name;
+		},
+		[factHandlerKind.runTimeKey]: null
+	});
+}
+//#endregion
+export { createFact, factKind };

package/dist/modeling/fact/index.d.ts

@@ -0,0 +1 @@
+export * from './base';

package/dist/modeling/flag/base.cjs

@@ -1,10 +1,8 @@
-const require_type = require("../../dataStructure/structure/defaults/type.cjs");
-const require_null = require("../../dataStructure/type/defaults/null.cjs");
 const require_kind = require("../kind.cjs");
 //#region scripts/modeling/flag/base.ts
 const flagKind = require_kind.createKind("flag");
 const flagHandlerKind = require_kind.createKind("flag-handler");
-function createFlag(entityStructure, name, valueStructure = require_type.TypeStructure(require_null.NullType(), [])) {
+function createFlag(name) {
 	function append(...args) {
 		if (args.length === 1) {
 			const [value] = args;
@@ -19,10 +17,8 @@ function createFlag(entityStructure, name, valueStructure = require_type.TypeStr
 	}
 	return {
 		name,
-		entityStructure,
-		valueStructure,
 		append,
-		getValue(entity) {
+		getPayload(entity) {
 			return flagKind.getValue(entity)[name];
 		},
 		has(entity) {

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

@@ -1,19 +1,18 @@
-import { EntityStructure, Entity, GetEntityName } from '../entity';
+import { EntityStructure, Entity } from '../entity';
 import type * as DKind from '../../kind';
-import * as DDataStructure from '../../dataStructure';
+import type * as DDataStructure from '../../dataStructure';
 export declare const flagKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/flag", Record<string, unknown>>>;
-export interface Flag<GenericName extends string = string, GenericValue extends unknown = never> extends DKind.Kind<typeof flagKind, Record<GenericName, GenericValue>> {
+export interface Flag<GenericName extends Capitalize<string> = Capitalize<string>, GenericPayload extends unknown = unknown> extends DKind.Kind<typeof flagKind, Record<GenericName, GenericPayload>> {
 }
+export type GetFlagName<GenericFlag extends Flag> = GenericFlag extends Flag<infer InferredName extends Capitalize<string>> ? InferredName : never;
+export type GetFlagPayload<GenericFlag extends Flag> = GenericFlag extends Flag<any, infer InferredPayload> ? InferredPayload : never;
 declare const flagHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/flag-handler", unknown>>;
-export interface FlagHandler<GenericEntity extends Entity = Entity, GenericName extends string = string, GenericValue extends unknown = unknown> extends DKind.Kind<typeof flagHandlerKind> {
+export interface FlagHandler<GenericName extends Capitalize<string> = Capitalize<string>, GenericEntity extends Entity = Entity, GenericPayload extends unknown = unknown> extends DKind.Kind<typeof flagHandlerKind> {
     readonly name: GenericName;
-    readonly entityStructure: EntityStructure<GetEntityName<GenericEntity>, Omit<GenericEntity, DKind.KeySymbol>>;
-    readonly valueStructure: DDataStructure.Structure<GenericValue>;
-    append<GenericInputEntity extends GenericEntity, const GenericInputValue extends GenericValue>(value: GenericInputValue): (entity: GenericInputEntity) => (GenericInputEntity & Flag<GenericName, GenericInputValue>);
-    append<GenericInputEntity extends GenericEntity, const GenericInputValue extends GenericValue>(entity: GenericInputEntity, value: GenericInputValue): (GenericInputEntity & Flag<GenericName, GenericInputValue>);
-    getValue<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericValue>>(entity: GenericInputEntity): DKind.GetValue<typeof flagKind, GenericInputEntity>[GenericName];
+    append<GenericInputEntity extends GenericEntity, const GenericInputPayload extends GenericPayload>(value: GenericInputPayload): (entity: GenericInputEntity) => (GenericInputEntity & Flag<GenericName, GenericInputPayload>);
+    append<GenericInputEntity extends GenericEntity, const GenericInputPayload extends GenericPayload>(entity: GenericInputEntity, value: GenericInputPayload): (GenericInputEntity & Flag<GenericName, GenericInputPayload>);
+    getPayload<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericPayload>>(entity: GenericInputEntity): DKind.GetValue<typeof flagKind, GenericInputEntity>[GenericName];
     has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): entity is Extract<GenericInputEntity, Flag<GenericName, any>>;
 }
-export declare function createFlag<GenericEntityStructure extends EntityStructure, GenericName extends Capitalize<string>, GenericValueStructure extends DDataStructure.Structure = DDataStructure.Structure<null>>(entityStructure: GenericEntityStructure, name: GenericName, valueStructure?: GenericValueStructure): FlagHandler<DDataStructure.StructureValue<GenericEntityStructure>, GenericName, DDataStructure.StructureValue<GenericValueStructure>>;
-export type GetFlag<GenericHandler extends FlagHandler<any, any, any>> = GenericHandler extends FlagHandler<any, infer InferredName, infer InferredValue> ? Flag<InferredName, InferredValue> : never;
+export declare function createFlag<GenericFLag extends Flag, GenericEntityStructure extends EntityStructure>(name: GetFlagName<GenericFLag>): FlagHandler<GetFlagName<GenericFLag>, DDataStructure.StructureValue<GenericEntityStructure>, GetFlagPayload<GenericFLag>>;
 export {};

package/dist/modeling/flag/base.mjs

@@ -1,10 +1,8 @@
-import { TypeStructure } from "../../dataStructure/structure/defaults/type.mjs";
-import { NullType } from "../../dataStructure/type/defaults/null.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/flag/base.ts
 const flagKind = createKind("flag");
 const flagHandlerKind = createKind("flag-handler");
-function createFlag(entityStructure, name, valueStructure = TypeStructure(NullType(), [])) {
+function createFlag(name) {
 	function append(...args) {
 		if (args.length === 1) {
 			const [value] = args;
@@ -19,10 +17,8 @@ function createFlag(entityStructure, name, valueStructure = TypeStructure(NullTy
 	}
 	return {
 		name,
-		entityStructure,
-		valueStructure,
 		append,
-		getValue(entity) {
+		getPayload(entity) {
 			return flagKind.getValue(entity)[name];
 		},
 		has(entity) {

package/dist/modeling/index.cjs

@@ -4,45 +4,50 @@ const require_base = require("./entity/base.cjs");
 const require_helper = require("./entity/helper.cjs");
 const require_base$1 = require("./newType/base.cjs");
 const require_helper$1 = require("./newType/helper.cjs");
-const require_base$2 = require("./flag/base.cjs");
 const require_namespace = require("./entity/namespace.cjs");
-const require_base$3 = require("./taggedObject/base.cjs");
+const require_base$2 = require("./fact/base.cjs");
+const require_base$3 = require("./flag/base.cjs");
+const require_base$4 = require("./taggedObject/base.cjs");
 const require_helper$2 = require("./taggedObject/helper.cjs");
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	EntityStructure: () => require_base.EntityStructure,
 	NewTypeStructure: () => require_base$1.NewTypeStructure,
-	TaggedObjectStructure: () => require_base$3.TaggedObjectStructure,
+	TaggedObjectStructure: () => require_base$4.TaggedObjectStructure,
 	createEntity: () => require_helper.createEntity,
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
-	createFlag: () => require_base$2.createFlag,
+	createFact: () => require_base$2.createFact,
+	createFlag: () => require_base$3.createFlag,
 	createKind: () => require_kind.createKind,
 	createNewType: () => require_helper$1.createNewType,
 	createTaggedObject: () => require_helper$2.createTaggedObject,
 	entityKind: () => require_base.entityKind,
 	entityStructureKind: () => require_base.entityStructureKind,
-	flagKind: () => require_base$2.flagKind,
+	factKind: () => require_base$2.factKind,
+	flagKind: () => require_base$3.flagKind,
 	getTagValue: () => require_helper$2.getTagValue,
 	hasTagValue: () => require_helper$2.hasTagValue,
 	namespaceKind: () => require_namespace.namespaceKind,
 	newTypeStructureKind: () => require_base$1.newTypeStructureKind,
-	objectTagKind: () => require_base$3.objectTagKind,
+	objectTagKind: () => require_base$4.objectTagKind,
 	taggedObject: () => require_helper$2.taggedObject,
-	taggedObjectStructureKind: () => require_base$3.taggedObjectStructureKind
+	taggedObjectStructureKind: () => require_base$4.taggedObjectStructureKind
 });
 //#endregion
 exports.EntityStructure = require_base.EntityStructure;
 exports.NewTypeStructure = require_base$1.NewTypeStructure;
-exports.TaggedObjectStructure = require_base$3.TaggedObjectStructure;
+exports.TaggedObjectStructure = require_base$4.TaggedObjectStructure;
 exports.createEntity = require_helper.createEntity;
 exports.createEntityNamespace = require_namespace.createEntityNamespace;
-exports.createFlag = require_base$2.createFlag;
+exports.createFact = require_base$2.createFact;
+exports.createFlag = require_base$3.createFlag;
 exports.createKind = require_kind.createKind;
 exports.createNewType = require_helper$1.createNewType;
 exports.createTaggedObject = require_helper$2.createTaggedObject;
 exports.entityKind = require_base.entityKind;
 exports.entityStructureKind = require_base.entityStructureKind;
-exports.flagKind = require_base$2.flagKind;
+exports.factKind = require_base$2.factKind;
+exports.flagKind = require_base$3.flagKind;
 exports.getTagValue = require_helper$2.getTagValue;
 exports.hasTagValue = require_helper$2.hasTagValue;
 Object.defineProperty(exports, "modeling_exports", {
@@ -53,6 +58,6 @@ Object.defineProperty(exports, "modeling_exports", {
 });
 exports.namespaceKind = require_namespace.namespaceKind;
 exports.newTypeStructureKind = require_base$1.newTypeStructureKind;
-exports.objectTagKind = require_base$3.objectTagKind;
+exports.objectTagKind = require_base$4.objectTagKind;
 exports.taggedObject = require_helper$2.taggedObject;
-exports.taggedObjectStructureKind = require_base$3.taggedObjectStructureKind;
+exports.taggedObjectStructureKind = require_base$4.taggedObjectStructureKind;

package/dist/modeling/index.d.ts

@@ -1,4 +1,5 @@
 export * from './entity';
+export * from './fact';
 export * from './flag';
 export * from './kind';
 export * from './newType';

package/dist/modeling/index.mjs

@@ -4,8 +4,9 @@ import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.
 import { createEntity } from "./entity/helper.mjs";
 import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
 import { createNewType } from "./newType/helper.mjs";
-import { createFlag, flagKind } from "./flag/base.mjs";
 import { createEntityNamespace, namespaceKind } from "./entity/namespace.mjs";
+import { createFact, factKind } from "./fact/base.mjs";
+import { createFlag, flagKind } from "./flag/base.mjs";
 import { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
 import { createTaggedObject, getTagValue, hasTagValue, taggedObject } from "./taggedObject/helper.mjs";
 //#region scripts/modeling/index.ts
@@ -15,12 +16,14 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	TaggedObjectStructure: () => TaggedObjectStructure,
 	createEntity: () => createEntity,
 	createEntityNamespace: () => createEntityNamespace,
+	createFact: () => createFact,
 	createFlag: () => createFlag,
 	createKind: () => createKind,
 	createNewType: () => createNewType,
 	createTaggedObject: () => createTaggedObject,
 	entityKind: () => entityKind,
 	entityStructureKind: () => entityStructureKind,
+	factKind: () => factKind,
 	flagKind: () => flagKind,
 	getTagValue: () => getTagValue,
 	hasTagValue: () => hasTagValue,
@@ -31,4 +34,4 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewType, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };
+export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFact, createFlag, createKind, createNewType, createTaggedObject, entityKind, entityStructureKind, factKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };

package/dist/modeling/newType/base.cjs

@@ -3,14 +3,14 @@ const require_create = require("../../either/left/create.cjs");
 const require_create$1 = require("../../either/right/create.cjs");
 const require_justExec = require("../../common/justExec.cjs");
 const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
-const require_error = require("../../dataStructure/common/error.cjs");
-const require_base = require("../../dataStructure/structure/base.cjs");
+const require_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = require("../../dataStructure/structure/base.cjs");
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = require("../kind.cjs").createKind("new-type-structure");
 function executeNewTypeConstraints(structure, data, errorHandler) {
 	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === require_resultSymbol.ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
 }
-const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
+const NewTypeStructure = require_base$1.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
@@ -18,6 +18,7 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
 	executeEncode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
 	executeDecode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	executeParse: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeParse(codecContext, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,
@@ -26,17 +27,17 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 			const [codecs] = args;
 			return (value) => self.decodeMap(codecs, value);
 		}
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const [codecs, data] = args;
 		const result = self.executeDecode(codecs.context.value, data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", result);
 	},
 	map: (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const result = self.executeCheck(data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", data);
 	},
@@ -46,18 +47,18 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 			return (value) => self.asyncDecodeMap(codecs, value);
 		}
 		return require_justExec.justExec(async () => {
-			const errorHandler = require_error.createGetErrorHandler();
+			const errorHandler = require_base.createGetErrorHandler();
 			const [codecs, data] = args;
 			const result = await self.executeDecode(codecs.context.value, data, errorHandler);
 			if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
-		const errorHandler = require_error.createGetErrorHandler();
+	asyncMap: async (self, data) => {
+		const errorHandler = require_base.createGetErrorHandler();
 		if (await self.executeCheck(data, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", data);
-	})
+	}
 }));
 //#endregion
 exports.NewTypeStructure = NewTypeStructure;

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

@@ -24,14 +24,14 @@ export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends rea
     readonly inner: DDataStructure.Structure;
     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.Forward<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
+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>> = Extract<GenericValue & GenericClearValue & NewType<GenericName, GenericIntersectionConstraintValue extends (GenericClearValue & infer InferredConstraint extends DCommon.BaseConstraint) ? InferredConstraint : never>, any>;
+export interface NewTypeStructure<out GenericName extends string = string, out GenericValue extends unknown = unknown, out 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>);
-    map(data: NewTypeMap<DDataStructure.StructureValue<this>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: NewTypeMap<DDataStructure.StructureValue<this>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>) => (DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>): (DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>): (DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>) => Promise<DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>): Promise<DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>): Promise<DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"map-error", DDataStructure.Error>>;
 }
 export declare const NewTypeStructure: <GenericName extends string, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[]>(name: GenericName, structure: GenericStructure, newTypeConstraints: GenericNewTypeConstraint) => NewTypeStructure<GenericName, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;