@duplojs/lang 0.0.0

package/dist/modeling/entity/entityName.mjs

@@ -0,0 +1,13 @@
+import { ErrorSymbol, SuccessSymbol } from "../../dataStructure/common/resultSymbol.mjs";
+import { createStructure } from "../../dataStructure/structure/base.mjs";
+import { createKind } from "../kind.mjs";
+//#region scripts/modeling/entity/entityName.ts
+const entityNameStructureKind = createKind("entity-name-structure");
+const EntityNameStructure = createStructure(entityNameStructureKind, ({ init }) => (name) => init({ constraints: [] }, {
+	executeCheck: (self, data, errorHandler) => data === name ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeEncode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeDecode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	isAsynchronous: () => false
+}, { name }));
+//#endregion
+export { EntityNameStructure, entityNameStructureKind };

package/dist/modeling/entity/helper.cjs

@@ -0,0 +1,7 @@
+const require_base = require("./base.cjs");
+//#region scripts/modeling/entity/helper.ts
+function createEntity(name, shape) {
+	return require_base.EntityStructure(name, shape);
+}
+//#endregion
+exports.createEntity = createEntity;

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

@@ -0,0 +1,15 @@
+import { Entity, EntityStructure } from './base';
+import { NewType } from '../newType';
+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]>>
+    ]>
+]> 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.`>;
+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/helper.mjs

@@ -0,0 +1,7 @@
+import { EntityStructure } from "./base.mjs";
+//#region scripts/modeling/entity/helper.ts
+function createEntity(name, shape) {
+	return EntityStructure(name, shape);
+}
+//#endregion
+export { createEntity };

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

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './entityName';
+export * from './helper';
+export * from './namespace';

package/dist/modeling/entity/namespace.cjs

@@ -0,0 +1,18 @@
+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) {
+	return {
+		name: entityName,
+		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewEntity(`${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
+	};
+}
+//#endregion
+exports.createEntityNamespace = createEntityNamespace;
+exports.namespaceKind = namespaceKind;

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

@@ -0,0 +1,15 @@
+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';
+export declare const namespaceKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/namespace", unknown>>;
+export interface EntityNamespace<GenericEntityName extends Capitalize<string> = Capitalize<string>> extends DKind.Kind<typeof namespaceKind> {
+    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

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

package/dist/modeling/flag/base.cjs

@@ -0,0 +1,36 @@
+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 append(...args) {
+		if (args.length === 1) {
+			const [value] = args;
+			return (entity) => append(entity, value);
+		}
+		const [entity, value] = args;
+		const flagValue = flagKind.has(entity) ? {
+			...flagKind.getValue(entity),
+			[name]: value
+		} : { [name]: value };
+		return flagKind.addTo(entity, flagValue);
+	}
+	return {
+		name,
+		entityStructure,
+		valueStructure,
+		append,
+		getValue(entity) {
+			return flagKind.getValue(entity)[name];
+		},
+		has(entity) {
+			return flagKind.has(entity) && name in flagKind.getValue(entity);
+		},
+		[flagHandlerKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.createFlag = createFlag;
+exports.flagKind = flagKind;

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

@@ -0,0 +1,19 @@
+import { EntityStructure, Entity, GetEntityName } from '../entity';
+import type * as DKind from '../../kind';
+import * 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>> {
+}
+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> {
+    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];
+    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 {};

package/dist/modeling/flag/base.mjs

@@ -0,0 +1,35 @@
+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 append(...args) {
+		if (args.length === 1) {
+			const [value] = args;
+			return (entity) => append(entity, value);
+		}
+		const [entity, value] = args;
+		const flagValue = flagKind.has(entity) ? {
+			...flagKind.getValue(entity),
+			[name]: value
+		} : { [name]: value };
+		return flagKind.addTo(entity, flagValue);
+	}
+	return {
+		name,
+		entityStructure,
+		valueStructure,
+		append,
+		getValue(entity) {
+			return flagKind.getValue(entity)[name];
+		},
+		has(entity) {
+			return flagKind.has(entity) && name in flagKind.getValue(entity);
+		},
+		[flagHandlerKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { createFlag, flagKind };

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

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

package/dist/modeling/index.cjs

@@ -0,0 +1,47 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("./kind.cjs");
+const require_entityName = require("./entity/entityName.cjs");
+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");
+//#region scripts/modeling/index.ts
+var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	EntityNameStructure: () => require_entityName.EntityNameStructure,
+	EntityStructure: () => require_base.EntityStructure,
+	NewTypeStructure: () => require_base$1.NewTypeStructure,
+	createEntity: () => require_helper.createEntity,
+	createEntityNamespace: () => require_namespace.createEntityNamespace,
+	createFlag: () => require_base$2.createFlag,
+	createKind: () => require_kind.createKind,
+	createNewEntity: () => require_helper$1.createNewEntity,
+	entityKind: () => require_base.entityKind,
+	entityNameStructureKind: () => require_entityName.entityNameStructureKind,
+	entityStructureKind: () => require_base.entityStructureKind,
+	flagKind: () => require_base$2.flagKind,
+	namespaceKind: () => require_namespace.namespaceKind,
+	newTypeStructureKind: () => require_base$1.newTypeStructureKind
+});
+//#endregion
+exports.EntityNameStructure = require_entityName.EntityNameStructure;
+exports.EntityStructure = require_base.EntityStructure;
+exports.NewTypeStructure = require_base$1.NewTypeStructure;
+exports.createEntity = require_helper.createEntity;
+exports.createEntityNamespace = require_namespace.createEntityNamespace;
+exports.createFlag = require_base$2.createFlag;
+exports.createKind = require_kind.createKind;
+exports.createNewEntity = require_helper$1.createNewEntity;
+exports.entityKind = require_base.entityKind;
+exports.entityNameStructureKind = require_entityName.entityNameStructureKind;
+exports.entityStructureKind = require_base.entityStructureKind;
+exports.flagKind = require_base$2.flagKind;
+Object.defineProperty(exports, "modeling_exports", {
+	enumerable: true,
+	get: function() {
+		return modeling_exports;
+	}
+});
+exports.namespaceKind = require_namespace.namespaceKind;
+exports.newTypeStructureKind = require_base$1.newTypeStructureKind;

package/dist/modeling/index.d.ts

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

package/dist/modeling/index.mjs

@@ -0,0 +1,28 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { createKind } from "./kind.mjs";
+import { EntityNameStructure, entityNameStructureKind } from "./entity/entityName.mjs";
+import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
+import { createEntity } from "./entity/helper.mjs";
+import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
+import { createNewEntity } from "./newType/helper.mjs";
+import { createFlag, flagKind } from "./flag/base.mjs";
+import { createEntityNamespace, namespaceKind } from "./entity/namespace.mjs";
+//#region scripts/modeling/index.ts
+var modeling_exports = /* @__PURE__ */ __exportAll({
+	EntityNameStructure: () => EntityNameStructure,
+	EntityStructure: () => EntityStructure,
+	NewTypeStructure: () => NewTypeStructure,
+	createEntity: () => createEntity,
+	createEntityNamespace: () => createEntityNamespace,
+	createFlag: () => createFlag,
+	createKind: () => createKind,
+	createNewEntity: () => createNewEntity,
+	entityKind: () => entityKind,
+	entityNameStructureKind: () => entityNameStructureKind,
+	entityStructureKind: () => entityStructureKind,
+	flagKind: () => flagKind,
+	namespaceKind: () => namespaceKind,
+	newTypeStructureKind: () => newTypeStructureKind
+});
+//#endregion
+export { EntityNameStructure, EntityStructure, NewTypeStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, entityKind, entityNameStructureKind, entityStructureKind, flagKind, modeling_exports, namespaceKind, newTypeStructureKind };

package/dist/modeling/kind.cjs

@@ -0,0 +1,4 @@
+//#region scripts/modeling/kind.ts
+const createKind = require("../kind/namespace.cjs").createNamespace("DuplojsLangModeling");
+//#endregion
+exports.createKind = createKind;

package/dist/modeling/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from '../kind';
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('../string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsLangModeling/${GenericName}`, GenericKindValue>>;

package/dist/modeling/kind.mjs

@@ -0,0 +1,5 @@
+import { createNamespace } from "../kind/namespace.mjs";
+//#region scripts/modeling/kind.ts
+const createKind = createNamespace("DuplojsLangModeling");
+//#endregion
+export { createKind };

package/dist/modeling/newType/base.cjs

@@ -0,0 +1,61 @@
+const require_callThen = require("../../common/callThen.cjs");
+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");
+//#region scripts/modeling/newType/base.ts
+const newTypeStructureKind = require("../kind.cjs").createKind("new-type-structure");
+const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
+	constraints: [],
+	newTypeConstraints,
+	inner: structure
+}, {
+	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol)),
+	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(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol), (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(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), require_resultSymbol.SuccessSymbol), (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,
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = require_error.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 === 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 result = self.executeCheck(data, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", data);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return require_justExec.justExec(async () => {
+			const errorHandler = require_error.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();
+		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;
+exports.newTypeStructureKind = newTypeStructureKind;

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

@@ -0,0 +1,37 @@
+import type * as DKind from '../../kind';
+import * as DCommon from '../../common';
+import type * as DArray from '../../array';
+import * as DEither from '../../either';
+import * as DDataStructure from '../../dataStructure';
+declare module '../../dataStructure' {
+    interface StructuresStore {
+        newType: NewTypeStructure;
+    }
+}
+export interface NewType<GenericName extends string = string, GenericConstraint extends DCommon.Constraint = never> extends DCommon.BaseConstraint<DCommon.SimplifyType<Record<"new-type", GenericName> & DCommon.UnionToIntersection<GenericConstraint[DCommon.ConstraintSymbol]>>> {
+}
+export type NewTypeMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends DDataStructure.FundamentalTypeValue<DDataStructure.FundamentalTypes> ? GenericRawValue : GenericRawValue extends object ? DCommon.Or<[
+    DCommon.IsExtends<GenericRawValue, readonly any[]>,
+    DCommon.And<[
+        DCommon.IsExtends<keyof GenericRawValue, string>,
+        DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
+    ]>
+]> extends true ? {
+    [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
+} : GenericRawValue : GenericRawValue;
+export declare const newTypeStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/new-type-structure", unknown>>;
+export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends readonly DDataStructure.Constraint[] = readonly DDataStructure.Constraint[]> extends DDataStructure.StructureDefinition<readonly []> {
+    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.UnionToIntersection<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>>;
+}
+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>;

package/dist/modeling/newType/base.mjs

@@ -0,0 +1,61 @@
+import { callThen } from "../../common/callThen.mjs";
+import { left } from "../../either/left/create.mjs";
+import { right } from "../../either/right/create.mjs";
+import { justExec } from "../../common/justExec.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../dataStructure/common/resultSymbol.mjs";
+import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { createStructure } from "../../dataStructure/structure/base.mjs";
+import { createKind } from "../kind.mjs";
+//#region scripts/modeling/newType/base.ts
+const newTypeStructureKind = createKind("new-type-structure");
+const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
+	constraints: [],
+	newTypeConstraints,
+	inner: structure
+}, {
+	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol)),
+	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), SuccessSymbol), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
+}, {
+	name,
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, data, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = createGetErrorHandler();
+		const result = self.executeCheck(data, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", data);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return justExec(async () => {
+			const errorHandler = createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, data, errorHandler);
+			if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+			return right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => justExec(async () => {
+		const errorHandler = createGetErrorHandler();
+		if (await self.executeCheck(data, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", data);
+	})
+}));
+//#endregion
+export { NewTypeStructure, newTypeStructureKind };

package/dist/modeling/newType/helper.cjs

@@ -0,0 +1,7 @@
+const require_base = require("./base.cjs");
+//#region scripts/modeling/newType/helper.ts
+function createNewEntity(name, structure, newTypeConstraints = []) {
+	return require_base.NewTypeStructure(name, structure, newTypeConstraints);
+}
+//#endregion
+exports.createNewEntity = createNewEntity;

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

@@ -0,0 +1,5 @@
+import { NewType, NewTypeStructure } from './base';
+import type * as DCommon from '../../common';
+import type * as DDataStructure from '../../dataStructure';
+export type ForbiddenTopLevelNewType<GenericValue extends unknown> = GenericValue extends NewType ? DCommon.ComputedTypeError<"NewType on top level of NewType declaration is forbidden."> : never;
+export declare function createNewEntity<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<GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;

package/dist/modeling/newType/helper.mjs

@@ -0,0 +1,7 @@
+import { NewTypeStructure } from "./base.mjs";
+//#region scripts/modeling/newType/helper.ts
+function createNewEntity(name, structure, newTypeConstraints = []) {
+	return NewTypeStructure(name, structure, newTypeConstraints);
+}
+//#endregion
+export { createNewEntity };

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

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

package/dist/number/betweenThan.cjs

@@ -0,0 +1,11 @@
+//#region scripts/number/betweenThan.ts
+function betweenThan(...args) {
+	if (args.length === 2) {
+		const [greater, less] = args;
+		return (value) => betweenThan(value, greater, less);
+	}
+	const [value, greater, less] = args;
+	return value > greater && value < less;
+}
+//#endregion
+exports.betweenThan = betweenThan;

package/dist/number/betweenThan.d.ts

@@ -0,0 +1,13 @@
+import { ComputeGreaterThanCompatibility, ComputeLessThanCompatibility, GreaterThan, IsImpossibleToApplyGreaterThan, IsImpossibleToApplyLessThan, LessThan } from './constraints';
+import { RequireSimpleLiteral } from './types';
+import type * as DCommon from '../common';
+type ApplyGreaterThan<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThan<GenericValue, GreaterThan<GenericThreshold>> extends true ? never : ComputeGreaterThanCompatibility<GenericValue, GreaterThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & GreaterThan<GenericThreshold> : never : never;
+type ApplyLessThan<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThan<GenericValue, LessThan<GenericThreshold>> extends true ? never : ComputeLessThanCompatibility<GenericValue, LessThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & LessThan<GenericThreshold> : never : never;
+type BetweenThanOutput<GenericValue extends number, GenericGreater extends number, GenericLess extends number> = ApplyLessThan<ApplyGreaterThan<GenericValue, GenericGreater>, GenericLess>;
+type RequireApplyBetweenThan<GenericNumber extends number> = RequireSimpleLiteral<GenericNumber>;
+type RequireApplyBetweenThanBoolean<GenericNumber extends number> = DCommon.IsEqual<GenericNumber, number> extends true ? unknown : RequireApplyBetweenThan<GenericNumber>;
+export declare function betweenThan<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(greater: GenericGreater & RequireApplyBetweenThan<GenericGreater>, less: GenericLess & RequireApplyBetweenThan<GenericLess>): (value: GenericValue) => value is BetweenThanOutput<GenericValue, GenericGreater, GenericLess>;
+export declare function betweenThan<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(greater: GenericGreater & RequireApplyBetweenThanBoolean<GenericGreater>, less: GenericLess & RequireApplyBetweenThanBoolean<GenericLess>): (value: GenericValue) => boolean;
+export declare function betweenThan<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(value: GenericValue, greater: GenericGreater & RequireApplyBetweenThan<GenericGreater>, less: GenericLess & RequireApplyBetweenThan<GenericLess>): value is BetweenThanOutput<GenericValue, GenericGreater, GenericLess>;
+export declare function betweenThan<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(value: GenericValue, greater: GenericGreater & RequireApplyBetweenThanBoolean<GenericGreater>, less: GenericLess & RequireApplyBetweenThanBoolean<GenericLess>): boolean;
+export {};

package/dist/number/betweenThan.mjs

@@ -0,0 +1,11 @@
+//#region scripts/number/betweenThan.ts
+function betweenThan(...args) {
+	if (args.length === 2) {
+		const [greater, less] = args;
+		return (value) => betweenThan(value, greater, less);
+	}
+	const [value, greater, less] = args;
+	return value > greater && value < less;
+}
+//#endregion
+export { betweenThan };

package/dist/number/betweenThanOrEqual.cjs

@@ -0,0 +1,11 @@
+//#region scripts/number/betweenThanOrEqual.ts
+function betweenThanOrEqual(...args) {
+	if (args.length === 2) {
+		const [greater, less] = args;
+		return (value) => betweenThanOrEqual(value, greater, less);
+	}
+	const [value, greater, less] = args;
+	return value >= greater && value <= less;
+}
+//#endregion
+exports.betweenThanOrEqual = betweenThanOrEqual;

package/dist/number/betweenThanOrEqual.d.ts

@@ -0,0 +1,13 @@
+import { ComputeGreaterThanOrEqualCompatibility, ComputeLessThanOrEqualCompatibility, GreaterThanOrEqual, IsImpossibleToApplyGreaterThanOrEqual, IsImpossibleToApplyLessThanOrEqual, LessThanOrEqual } from './constraints';
+import { RequireSimpleLiteral } from './types';
+import type * as DCommon from '../common';
+type ApplyGreaterThanOrEqual<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThanOrEqual<GenericValue, GreaterThanOrEqual<GenericThreshold>> extends true ? never : ComputeGreaterThanOrEqualCompatibility<GenericValue, GreaterThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & GreaterThanOrEqual<GenericThreshold> : never : never;
+type ApplyLessThanOrEqual<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThanOrEqual<GenericValue, LessThanOrEqual<GenericThreshold>> extends true ? never : ComputeLessThanOrEqualCompatibility<GenericValue, LessThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & LessThanOrEqual<GenericThreshold> : never : never;
+type BetweenThanOrEqualOutput<GenericValue extends number, GenericGreater extends number, GenericLess extends number> = ApplyLessThanOrEqual<ApplyGreaterThanOrEqual<GenericValue, GenericGreater>, GenericLess>;
+type RequireApplyBetweenThanOrEqual<GenericNumber extends number> = RequireSimpleLiteral<GenericNumber>;
+type RequireApplyBetweenThanOrEqualBoolean<GenericNumber extends number> = DCommon.IsEqual<GenericNumber, number> extends true ? unknown : RequireApplyBetweenThanOrEqual<GenericNumber>;
+export declare function betweenThanOrEqual<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(greater: GenericGreater & RequireApplyBetweenThanOrEqual<GenericGreater>, less: GenericLess & RequireApplyBetweenThanOrEqual<GenericLess>): (value: GenericValue) => value is BetweenThanOrEqualOutput<GenericValue, GenericGreater, GenericLess>;
+export declare function betweenThanOrEqual<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(greater: GenericGreater & RequireApplyBetweenThanOrEqualBoolean<GenericGreater>, less: GenericLess & RequireApplyBetweenThanOrEqualBoolean<GenericLess>): (value: GenericValue) => boolean;
+export declare function betweenThanOrEqual<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(value: GenericValue, greater: GenericGreater & RequireApplyBetweenThanOrEqual<GenericGreater>, less: GenericLess & RequireApplyBetweenThanOrEqual<GenericLess>): value is BetweenThanOrEqualOutput<GenericValue, GenericGreater, GenericLess>;
+export declare function betweenThanOrEqual<GenericValue extends number, const GenericGreater extends number, const GenericLess extends number>(value: GenericValue, greater: GenericGreater & RequireApplyBetweenThanOrEqualBoolean<GenericGreater>, less: GenericLess & RequireApplyBetweenThanOrEqualBoolean<GenericLess>): boolean;
+export {};

package/dist/number/betweenThanOrEqual.mjs

@@ -0,0 +1,11 @@
+//#region scripts/number/betweenThanOrEqual.ts
+function betweenThanOrEqual(...args) {
+	if (args.length === 2) {
+		const [greater, less] = args;
+		return (value) => betweenThanOrEqual(value, greater, less);
+	}
+	const [value, greater, less] = args;
+	return value >= greater && value <= less;
+}
+//#endregion
+export { betweenThanOrEqual };

package/dist/number/constraints/even.d.ts

@@ -0,0 +1,3 @@
+import type * as DCommon from '../../common';
+export interface Even extends DCommon.Constraint<"even-number"> {
+}