@duplojs/utils 1.2.18 → 1.3.19

package/dist/array/some.cjs

@@ -3,10 +3,13 @@
 function some(...args) {
     if (args.length === 1) {
         const [predicate] = args;
-        return (array) => some(array, predicate);
+        return (input) => some(input, predicate);
     }
-    const [array, predicate] = args;
-    return array.some((element, index) => predicate(element, { index }));
+    const [input, predicate] = args;
+    return input.some((element, index) => predicate(element, {
+        index,
+        self: input,
+    }));
 }
 
 exports.some = some;

package/dist/array/some.d.ts

@@ -1,6 +1,7 @@
-interface ArraySomeParams {
+interface ArraySomeParams<GenericInputArray extends readonly unknown[]> {
     index: number;
+    self: GenericInputArray;
 }
-export declare function some<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArraySomeParams) => boolean): (array: GenericArray) => boolean;
-export declare function some<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArraySomeParams) => boolean): boolean;
+export declare function some<GenericInput extends readonly unknown[]>(predicate: (element: GenericInput[number], params: ArraySomeParams<GenericInput>) => boolean): (input: GenericInput) => boolean;
+export declare function some<GenericInput extends readonly unknown[]>(input: GenericInput, predicate: (element: GenericInput[number], params: ArraySomeParams<GenericInput>) => boolean): boolean;
 export {};

package/dist/array/some.mjs

@@ -1,10 +1,13 @@
 function some(...args) {
     if (args.length === 1) {
         const [predicate] = args;
-        return (array) => some(array, predicate);
+        return (input) => some(input, predicate);
     }
-    const [array, predicate] = args;
-    return array.some((element, index) => predicate(element, { index }));
+    const [input, predicate] = args;
+    return input.some((element, index) => predicate(element, {
+        index,
+        self: input,
+    }));
 }
 
 export { some };

package/dist/array/types/ArrayCoalescing.d.ts

@@ -1 +1 @@
-export type ArrayCoalescing<GenericValue extends unknown> = GenericValue extends readonly any[] ? GenericValue : [GenericValue];
+export type ArrayCoalescing<GenericValue extends unknown> = GenericValue extends readonly any[] ? GenericValue : readonly [GenericValue];

package/dist/clean/constraint/base.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var kind$1 = require('../../common/kind.cjs');
+var coalescing = require('../../array/coalescing.cjs');
+var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var is = require('../../either/left/is.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var create = require('../../either/left/create.cjs');
+var create$1 = require('../../either/right/create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+
+const constrainedTypeKind = kind.createCleanKind("constrained-type");
+const constraintHandlerKind = kind.createCleanKind("constraint-handler");
+class CreateConstrainedTypeError extends kind$1.kindHeritage("create-constrained-type-error", errorKindNamespace.createErrorKind("create-constrained-type-error"), Error) {
+    constrainedTypeName;
+    data;
+    dataParserError;
+    constructor(constrainedTypeName, data, dataParserError) {
+        super({}, [`Error when create constrained type ${constrainedTypeName}.`]);
+        this.constrainedTypeName = constrainedTypeName;
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+function createConstraint(name, primitiveHandler, checker) {
+    const checkers = coalescing.coalescing(checker);
+    const dataParserWithCheckers = primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    function create$2(data) {
+        const result = dataParserWithCheckers.parse(unwrap.unwrap(data));
+        if (is.isLeft(result)) {
+            return create.left("createConstrainedTypeError", unwrap.unwrap(result));
+        }
+        else if (constrainedTypeKind.has(data)) {
+            return create$1.right("createConstrainedType", constrainedTypeKind.addTo(data, {
+                ...constrainedTypeKind.getValue(data),
+                [name]: null,
+            }));
+        }
+        else {
+            return create$1.right("createConstrainedType", constrainedTypeKind.setTo(wrapValue.wrapValue(unwrap.unwrap(result)), { [name]: null }));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create$2(data);
+        if (is.isLeft(result)) {
+            throw new CreateConstrainedTypeError(name, data, unwrap.unwrap(result));
+        }
+        else {
+            return unwrap.unwrap(result);
+        }
+    }
+    function is$1(input) {
+        if (constrainedTypeKind.has(input)
+            && constrainedTypeKind.getValue(input)[name] === null) {
+            return true;
+        }
+        return false;
+    }
+    return constraintHandlerKind.setTo({
+        name,
+        primitiveHandler,
+        checkers,
+        create: create$2,
+        createOrThrow,
+        createWithUnknown: create$2,
+        createWithUnknownOrThrow: createOrThrow,
+        is: is$1,
+    });
+}
+
+exports.CreateConstrainedTypeError = CreateConstrainedTypeError;
+exports.constrainedTypeKind = constrainedTypeKind;
+exports.constraintHandlerKind = constraintHandlerKind;
+exports.createConstraint = createConstraint;

package/dist/clean/constraint/base.d.ts

@@ -0,0 +1,36 @@
+import { type Unwrap, type Kind, type WrappedValue } from "../..";
+import { type Primitive, type EligiblePrimitive, type PrimitiveHandler } from "../primitive";
+import * as DArray from "../../array";
+import * as DEither from "../../either";
+import type * as DDataParser from "../../dataParser";
+export declare const constrainedTypeKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constrained-type", Record<string, unknown>>>;
+export interface ConstrainedType<GenericName extends string, GenericValue extends unknown> extends Kind<typeof constrainedTypeKind.definition, Record<GenericName, unknown>>, WrappedValue<GenericValue> {
+}
+export declare const constraintHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraint-handler", unknown>>;
+export interface ConstraintHandler<GenericName extends string = string, GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericCheckers extends readonly DDataParser.DataParserChecker[] = readonly DDataParser.DataParserChecker[]> extends Kind<typeof constraintHandlerKind.definition> {
+    readonly name: GenericName;
+    readonly checkers: GenericCheckers;
+    readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
+    create<GenericData extends GenericPrimitiveValue>(data: GenericData): (DEither.EitherRight<"createConstrainedType", ConstrainedType<GenericName, GenericData>> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.EitherRight<"createConstrainedType", (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>)> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    createOrThrow<GenericData extends GenericPrimitiveValue>(data: GenericData): ConstrainedType<GenericName, GenericData>;
+    createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>);
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createConstrainedType", ConstrainedType<GenericName, GenericPrimitiveValue>> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): ConstrainedType<GenericName, GenericPrimitiveValue>;
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, ConstrainedType<GenericName, GenericPrimitiveValue>>;
+}
+declare const CreateConstrainedTypeError_base: new (params: {
+    "@DuplojsUtilsError/create-constrained-type-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../..").KindDefinition<"create-constrained-type-error", unknown>, unknown> & Kind<import("../..").KindDefinition<"@DuplojsUtilsError/create-constrained-type-error", unknown>, unknown>;
+export declare class CreateConstrainedTypeError extends CreateConstrainedTypeError_base {
+    constrainedTypeName: string;
+    data: unknown;
+    dataParserError: DDataParser.DataParserError;
+    constructor(constrainedTypeName: string, data: unknown, dataParserError: DDataParser.DataParserError);
+}
+export declare function createConstraint<GenericName extends string, GenericPrimitiveValue extends EligiblePrimitive, const GenericChecker extends (DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue> | readonly [
+    DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>,
+    ...DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]
+]) = never>(name: GenericName, primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, checker: GenericChecker): ConstraintHandler<GenericName, GenericPrimitiveValue, DArray.ArrayCoalescing<GenericChecker>>;
+export type Constraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
+export {};

package/dist/clean/constraint/base.mjs

@@ -0,0 +1,72 @@
+import { createCleanKind } from '../kind.mjs';
+import { kindHeritage } from '../../common/kind.mjs';
+import { coalescing } from '../../array/coalescing.mjs';
+import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { isLeft } from '../../either/left/is.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { left } from '../../either/left/create.mjs';
+import { right } from '../../either/right/create.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+
+const constrainedTypeKind = createCleanKind("constrained-type");
+const constraintHandlerKind = createCleanKind("constraint-handler");
+class CreateConstrainedTypeError extends kindHeritage("create-constrained-type-error", createErrorKind("create-constrained-type-error"), Error) {
+    constrainedTypeName;
+    data;
+    dataParserError;
+    constructor(constrainedTypeName, data, dataParserError) {
+        super({}, [`Error when create constrained type ${constrainedTypeName}.`]);
+        this.constrainedTypeName = constrainedTypeName;
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+function createConstraint(name, primitiveHandler, checker) {
+    const checkers = coalescing(checker);
+    const dataParserWithCheckers = primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    function create(data) {
+        const result = dataParserWithCheckers.parse(unwrap(data));
+        if (isLeft(result)) {
+            return left("createConstrainedTypeError", unwrap(result));
+        }
+        else if (constrainedTypeKind.has(data)) {
+            return right("createConstrainedType", constrainedTypeKind.addTo(data, {
+                ...constrainedTypeKind.getValue(data),
+                [name]: null,
+            }));
+        }
+        else {
+            return right("createConstrainedType", constrainedTypeKind.setTo(wrapValue(unwrap(result)), { [name]: null }));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create(data);
+        if (isLeft(result)) {
+            throw new CreateConstrainedTypeError(name, data, unwrap(result));
+        }
+        else {
+            return unwrap(result);
+        }
+    }
+    function is(input) {
+        if (constrainedTypeKind.has(input)
+            && constrainedTypeKind.getValue(input)[name] === null) {
+            return true;
+        }
+        return false;
+    }
+    return constraintHandlerKind.setTo({
+        name,
+        primitiveHandler,
+        checkers,
+        create,
+        createOrThrow,
+        createWithUnknown: create,
+        createWithUnknownOrThrow: createOrThrow,
+        is,
+    });
+}
+
+export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint };

package/dist/{array/sort → clean/constraint/defaultConstraint}/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./default";
 export * from "./number";
 export * from "./string";

package/dist/clean/constraint/defaultConstraint/number.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var base = require('../base.cjs');
+var base$1 = require('../../primitive/base.cjs');
+var int = require('../../../dataParser/parsers/number/checkers/int.cjs');
+var min = require('../../../dataParser/parsers/number/checkers/min.cjs');
+var max = require('../../../dataParser/parsers/number/checkers/max.cjs');
+
+const Int = base.createConstraint("int", base$1.Number, int.checkerInt());
+const Positive = base.createConstraint("positive", base$1.Number, min.checkerNumberMin(1));
+const Negative = base.createConstraint("negative", base$1.Number, max.checkerNumberMax(-1));
+
+exports.Int = Int;
+exports.Negative = Negative;
+exports.Positive = Positive;

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -0,0 +1,8 @@
+import { type Constraint } from "../base";
+import * as DDataParser from "../../../dataParser";
+export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt]>;
+export type Int = Constraint<typeof Int>;
+export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin]>;
+export type Positive = Constraint<typeof Positive>;
+export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
+export type Negative = Constraint<typeof Negative>;

package/dist/clean/constraint/defaultConstraint/number.mjs

@@ -0,0 +1,11 @@
+import { createConstraint } from '../base.mjs';
+import { Number } from '../../primitive/base.mjs';
+import { checkerInt } from '../../../dataParser/parsers/number/checkers/int.mjs';
+import { checkerNumberMin } from '../../../dataParser/parsers/number/checkers/min.mjs';
+import { checkerNumberMax } from '../../../dataParser/parsers/number/checkers/max.mjs';
+
+const Int = createConstraint("int", Number, checkerInt());
+const Positive = createConstraint("positive", Number, checkerNumberMin(1));
+const Negative = createConstraint("negative", Number, checkerNumberMax(-1));
+
+export { Int, Negative, Positive };

package/dist/clean/constraint/defaultConstraint/string.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var base = require('../base.cjs');
+var base$1 = require('../../primitive/base.cjs');
+var email = require('../../../dataParser/parsers/string/checkers/email.cjs');
+var url = require('../../../dataParser/parsers/string/checkers/url.cjs');
+
+const Email = base.createConstraint("email", base$1.String, email.checkerEmail());
+const Url = base.createConstraint("url", base$1.String, url.checkerUrl());
+
+exports.Email = Email;
+exports.Url = Url;

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -0,0 +1,6 @@
+import { type Constraint } from "../base";
+import * as DDataParser from "../../../dataParser";
+export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail]>;
+export type Email = Constraint<typeof Email>;
+export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
+export type Url = Constraint<typeof Url>;

package/dist/clean/constraint/defaultConstraint/string.mjs

@@ -0,0 +1,9 @@
+import { createConstraint } from '../base.mjs';
+import { String } from '../../primitive/base.mjs';
+import { checkerEmail } from '../../../dataParser/parsers/string/checkers/email.mjs';
+import { checkerUrl } from '../../../dataParser/parsers/string/checkers/url.mjs';
+
+const Email = createConstraint("email", String, checkerEmail());
+const Url = createConstraint("url", String, checkerUrl());
+
+export { Email, Url };

package/dist/clean/constraint/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./defaultConstraint";

package/dist/clean/entity.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+var newType = require('./newType.cjs');
+var kind$1 = require('../common/kind.cjs');
+var pipe = require('../common/pipe.cjs');
+var filter = require('../array/filter.cjs');
+var isType = require('../common/isType.cjs');
+var map = require('../array/map.cjs');
+var entry = require('../object/entry.cjs');
+var toTuple = require('../array/toTuple.cjs');
+var first = require('../array/at/first.cjs');
+var innerPipe = require('../common/innerPipe.cjs');
+var when = require('../pattern/when.cjs');
+var exhaustive = require('../pattern/exhaustive.cjs');
+var when$1 = require('../common/when.cjs');
+var index = require('../dataParser/parsers/array/index.cjs');
+var min = require('../dataParser/parsers/array/checkers/min.cjs');
+var max = require('../dataParser/parsers/array/checkers/max.cjs');
+var nullable = require('../dataParser/parsers/nullable.cjs');
+var base = require('../dataParser/base.cjs');
+var last = require('../array/at/last.cjs');
+var entries = require('../object/entries.cjs');
+var forward = require('../common/forward.cjs');
+var errorKindNamespace = require('../common/errorKindNamespace.cjs');
+var fromEntries = require('../object/fromEntries.cjs');
+var transform = require('../dataParser/parsers/transform.cjs');
+var base$1 = require('./constraint/base.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+var otherwise = require('../pattern/otherwise.cjs');
+var justReturn = require('../common/justReturn.cjs');
+var union = require('../dataParser/parsers/union.cjs');
+var minElements = require('../array/minElements.cjs');
+var is = require('../either/left/is.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var create = require('../either/left/create.cjs');
+var create$1 = require('../either/right/create.cjs');
+var index$1 = require('../dataParser/parsers/object/index.cjs');
+
+const entityKind = kind.createCleanKind("entity");
+const entityHandlerKind = kind.createCleanKind("entity-handler");
+class CreateEntityError extends kind$1.kindHeritage("create-entity-error", errorKindNamespace.createErrorKind("create-entity-error"), Error) {
+    rawProperties;
+    dataParserError;
+    constructor(rawProperties, dataParserError) {
+        super({}, ["Error when create entity."]);
+        this.rawProperties = rawProperties;
+        this.dataParserError = dataParserError;
+    }
+}
+function createEntity(name, getPropertiesDefinition) {
+    function theNew(properties) {
+        return entityKind.addTo(properties, name);
+    }
+    function simplePropertyDefinitionToDataParser(simplePropertyDefinition) {
+        const constraintKindValue = pipe.pipe(simplePropertyDefinition.constrains, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+        return transform.transform(simplePropertyDefinition.dataParser, (value) => base$1.constrainedTypeKind.setTo(newType.newTypeKind.setTo(wrapValue.wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
+    }
+    function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {
+        return pipe.pipe(unionPropertyDefinition, map.map(simplePropertyDefinitionToDataParser), when.when(minElements.minElements(1), union.union), otherwise.otherwise(justReturn.justReturn(null)));
+    }
+    const params = {
+        union: (...type) => ({ type }),
+        array: (definition, params) => (newType.newTypeHandlerKind.has(definition) || definition instanceof Array
+            ? {
+                type: definition,
+                inArray: params ?? true,
+            }
+            : {
+                ...definition,
+                inArray: params ?? true,
+            }),
+        nullable: (definition) => (newType.newTypeHandlerKind.has(definition) || definition instanceof Array
+            ? {
+                type: definition,
+                nullable: true,
+            }
+            : {
+                ...definition,
+                nullable: true,
+            }),
+    };
+    const propertiesDefinition = getPropertiesDefinition(params);
+    const mapDataParser = pipe.pipe(forward.forward(propertiesDefinition), entries.entries, map.map(toTuple.toTuple([
+        first.first,
+        innerPipe.innerPipe(last.last, when.when(newType.newTypeHandlerKind.has, simplePropertyDefinitionToDataParser), when.when(isType.isType("array"), unionPropertyDefinitionToDataParser), when.when(isType.isType("object"), (definition) => pipe.pipe(definition.type, when.when(newType.newTypeHandlerKind.has, simplePropertyDefinitionToDataParser), when.when(isType.isType("array"), unionPropertyDefinitionToDataParser), exhaustive.exhaustive, when$1.when(base.dataParserKind.has, innerPipe.innerPipe((dataParser) => {
+            if (definition.inArray) {
+                return pipe.pipe(index.array(dataParser), (dataParser) => typeof definition.inArray === "object"
+                    && definition.inArray.min !== undefined
+                    ? dataParser.addChecker(min.checkerArrayMin(definition.inArray.min))
+                    : dataParser, (dataParser) => typeof definition.inArray === "object"
+                    && definition.inArray.max !== undefined
+                    ? dataParser.addChecker(max.checkerArrayMax(definition.inArray.max))
+                    : dataParser);
+            }
+            return dataParser;
+        }, when$1.when(() => definition.nullable === true, nullable.nullable))))), exhaustive.exhaustive),
+    ])), map.map(([key, value]) => value !== null && entry.entry(key, value)), filter.filter(isType.isType("array")), fromEntries.fromEntries, index$1.object, (dataParser) => transform.transform(dataParser, (value) => entityKind.setTo(value, name)));
+    function map$1(rawProperties) {
+        const result = mapDataParser.parse(rawProperties);
+        if (is.isLeft(result)) {
+            return create.left("createEntityError", unwrap.unwrap(result));
+        }
+        return create$1.right("createEntity", unwrap.unwrap(result));
+    }
+    function mapOrThrow(rawProperties) {
+        const result = mapDataParser.parse(rawProperties);
+        if (is.isLeft(result)) {
+            throw new CreateEntityError(rawProperties, unwrap.unwrap(result));
+        }
+        return unwrap.unwrap(result);
+    }
+    return entityHandlerKind.setTo({
+        name,
+        propertiesDefinition,
+        mapDataParser,
+        new: theNew,
+        map: map$1,
+        mapOrThrow,
+    });
+}
+
+exports.CreateEntityError = CreateEntityError;
+exports.createEntity = createEntity;
+exports.entityKind = entityKind;

package/dist/clean/entity.d.ts

@@ -0,0 +1,74 @@
+import { type SimplifyTopLevel, type Kind, type Unwrap, type IsEqual, type IsExtends, type Or, type NeverCoalescing } from "../common";
+import { type GetNewType, type NewTypeHandler } from "./newType";
+import * as DEither from "../either";
+import * as DDataParser from "../dataParser";
+import * as DObject from "../object";
+import * as DArray from "../array";
+export type EntitySimplePropertyDefinition = NewTypeHandler<string, unknown, readonly any[]>;
+export type EntityUnionPropertyDefinition = readonly [
+    EntitySimplePropertyDefinition,
+    ...EntitySimplePropertyDefinition[]
+];
+export interface EntityAdvancedArrayPropertyDefinition {
+    min?: number;
+    max?: number;
+}
+export interface EntityAdvancedPropertyDefinition {
+    type: (EntitySimplePropertyDefinition | EntityUnionPropertyDefinition);
+    nullable?: true;
+    inArray?: true | EntityAdvancedArrayPropertyDefinition;
+}
+export type EntityPropertyDefinition = (EntitySimplePropertyDefinition | EntityUnionPropertyDefinition | EntityAdvancedPropertyDefinition);
+export type EntityPropertiesDefinition = Readonly<Record<string, EntityPropertyDefinition>>;
+export type EntityProperties<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
+    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? GetNewType<GenericPropertiesDefinition[Prop]> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? GetNewType<GenericPropertiesDefinition[Prop][number]> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? GetNewType<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never> extends infer InferredValue ? (IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true> extends true ? readonly InferredValue[] : GenericPropertiesDefinition[Prop]["inArray"] extends object ? GenericPropertiesDefinition[Prop]["inArray"]["min"] extends number ? readonly [
+        ...DArray.CreateTuple<InferredValue, GenericPropertiesDefinition[Prop]["inArray"]["min"]>,
+        ...InferredValue[]
+    ] : readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : unknown);
+}>;
+export type EntityRawProperties<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
+    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop]>> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop][number]>> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never>> extends infer InferredValue ? (Or<[
+        IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true>,
+        IsExtends<GenericPropertiesDefinition[Prop]["inArray"], object>
+    ]> extends true ? readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : never);
+}>;
+export declare const entityKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/entity", string>>;
+export interface Entity<GenericName extends string = string> extends Kind<typeof entityKind.definition, GenericName> {
+}
+declare const entityHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/entity-handler", unknown>>;
+export interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> extends Kind<typeof entityHandlerKind.definition> {
+    readonly name: GenericName;
+    readonly propertiesDefinition: GenericPropertiesDefinition;
+    readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, EntityRawProperties<GenericPropertiesDefinition>>;
+    "new"<GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
+    map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
+    mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
+}
+declare const CreateEntityError_base: new (params: {
+    "@DuplojsUtilsError/create-entity-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../common").KindDefinition<"create-entity-error", unknown>, unknown> & Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-entity-error", unknown>, unknown>;
+export declare class CreateEntityError extends CreateEntityError_base {
+    rawProperties: EntityRawProperties;
+    dataParserError: DDataParser.DataParserError;
+    constructor(rawProperties: EntityRawProperties, dataParserError: DDataParser.DataParserError);
+}
+export interface PropertiesDefinitionParams {
+    union<const GenericUnionPropertyDefinition extends EntityUnionPropertyDefinition>(...type: GenericUnionPropertyDefinition): {
+        type: GenericUnionPropertyDefinition;
+    };
+    nullable<const GenericPropertyDefinition extends EntityPropertyDefinition>(definition: GenericPropertyDefinition): GenericPropertyDefinition extends EntityAdvancedPropertyDefinition ? DObject.AssignObjects<GenericPropertyDefinition, {
+        nullable: true;
+    }> : {
+        type: GenericPropertyDefinition;
+        nullable: true;
+    };
+    array<const GenericPropertyDefinition extends EntityPropertyDefinition, const GenericAdvancedArrayPropertyDefinition extends EntityAdvancedArrayPropertyDefinition = never>(definition: GenericPropertyDefinition, params?: GenericAdvancedArrayPropertyDefinition): GenericPropertyDefinition extends EntityAdvancedPropertyDefinition ? DObject.AssignObjects<GenericPropertyDefinition, {
+        inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
+    }> : {
+        type: GenericPropertyDefinition;
+        inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
+    };
+}
+export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition): EntityHandler<GenericName, GenericPropertiesDefinition>;
+export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
+export {};