@duplojs/lang 0.0.1-beta.10 → 0.0.1-beta.11

package/dist/dataStructure/common/error/defaultInterpreter.cjs

@@ -7,59 +7,62 @@ const require_string = require("../codec/defaults/string.cjs");
 const require_base = require("./base.cjs");
 //#region scripts/dataStructure/common/error/defaultInterpreter.ts
 const defaultErrorInterpreterDataStructureDictionary = {
-	"array-structure": () => "Expected an array.",
-	"lazy-structure": () => "Expected a value matching the resolved structure.",
-	"non-encodable-string-structure": (source) => `Expected ${require_stringify.stringify(source.definition.value)}.`,
-	"object-structure": () => "Expected a plain object containing only the defined properties.",
-	"record-structure": () => "Expected a plain object matching the record definition.",
-	"type-structure": () => "Expected a value matching the configured type.",
-	"union-structure": () => "Expected a value matching at least one union member.",
-	"bigint-type": () => "Expected a bigint.",
-	"bigint-literal-type": (source) => `Expected ${require_to.to(source.definition.value)}n.`,
-	"boolean-type": () => "Expected a boolean.",
-	"boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
-	"date-type": () => "Expected a DuploJS date.",
-	"null-type": () => "Expected null.",
-	"number-type": () => "Expected a finite number.",
-	"number-literal-type": (source) => `Expected ${source.definition.value}.`,
-	"string-type": () => "Expected a string.",
-	"string-literal-type": (source) => `Expected ${require_stringify.stringify(source.definition.value)}.`,
-	"time-type": () => "Expected a DuploJS time.",
-	"undefined-type": () => "Expected undefined.",
-	"absolute-path-constraint": () => "Expected an absolute path.",
-	"allowed-characters-constraint": (source) => `Expected a string containing only characters from ${require_join.join(require_coalescing.coalescing(source.definition.charactersRange), ", ")}.`,
-	"array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
-	"between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
-	"between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
-	"email-constraint": () => "Expected a valid email address.",
-	"even-constraint": () => "Expected an even number.",
-	"greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
-	"greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
-	"integer-constraint": () => "Expected an integer.",
-	"less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
-	"less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
-	"max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
-	"max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
-	"min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
-	"min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
-	"multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
-	"negative-constraint": () => "Expected a number less than or equal to zero.",
-	"not-empty-constraint": () => "Expected a non-empty string.",
-	"not-zero-constraint": () => "Expected a non-zero number.",
-	"number-in-string-constraint": () => "Expected a string representing a number.",
-	"odd-constraint": () => "Expected an odd number.",
-	"path-constraint": () => "Expected a valid path.",
-	"positive-constraint": () => "Expected a number greater than or equal to zero.",
-	"refine-constraint": () => "Expected a value satisfying the custom refinement.",
-	"regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
-	"safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
-	"segment-path-constraint": () => "Expected a valid path segment.",
-	"strict-negative-constraint": () => "Expected a number less than zero.",
-	"strict-positive-constraint": () => "Expected a number greater than zero.",
-	"string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
-	"trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
-	"url-constraint": () => "Expected a valid URL.",
-	"uuid-constraint": () => "Expected a valid UUID."
+	"@DuplojsLangDataStructure/array-structure": () => "Expected an array.",
+	"@DuplojsLangDataStructure/lazy-structure": () => "Expected a value matching the resolved structure.",
+	"@DuplojsLangDataStructure/non-encodable-string-structure": (source) => `Expected ${require_stringify.stringify(source.definition.value)}.`,
+	"@DuplojsLangDataStructure/object-structure": () => "Expected a plain object containing only the defined properties.",
+	"@DuplojsLangDataStructure/record-structure": () => "Expected a plain object matching the record definition.",
+	"@DuplojsLangDataStructure/type-structure": () => "Expected a value matching the configured type.",
+	"@DuplojsLangDataStructure/union-structure": () => "Expected a value matching at least one union member.",
+	"@DuplojsLangDataStructure/bigint-type": () => "Expected a bigint.",
+	"@DuplojsLangDataStructure/bigint-literal-type": (source) => `Expected ${require_to.to(source.definition.value)}n.`,
+	"@DuplojsLangDataStructure/boolean-type": () => "Expected a boolean.",
+	"@DuplojsLangDataStructure/boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"@DuplojsLangDataStructure/date-type": () => "Expected a DuploJS date.",
+	"@DuplojsLangDataStructure/null-type": () => "Expected null.",
+	"@DuplojsLangDataStructure/number-type": () => "Expected a finite number.",
+	"@DuplojsLangDataStructure/number-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"@DuplojsLangDataStructure/string-type": () => "Expected a string.",
+	"@DuplojsLangDataStructure/string-literal-type": (source) => `Expected ${require_stringify.stringify(source.definition.value)}.`,
+	"@DuplojsLangDataStructure/time-type": () => "Expected a DuploJS time.",
+	"@DuplojsLangDataStructure/undefined-type": () => "Expected undefined.",
+	"@DuplojsLangDataStructure/absolute-path-constraint": () => "Expected an absolute path.",
+	"@DuplojsLangDataStructure/allowed-characters-constraint": (source) => `Expected a string containing only characters from ${require_join.join(require_coalescing.coalescing(source.definition.charactersRange), ", ")}.`,
+	"@DuplojsLangDataStructure/array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
+	"@DuplojsLangDataStructure/between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
+	"@DuplojsLangDataStructure/between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
+	"@DuplojsLangDataStructure/email-constraint": () => "Expected a valid email address.",
+	"@DuplojsLangDataStructure/even-constraint": () => "Expected an even number.",
+	"@DuplojsLangDataStructure/greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/integer-constraint": () => "Expected an integer.",
+	"@DuplojsLangDataStructure/less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
+	"@DuplojsLangDataStructure/max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
+	"@DuplojsLangDataStructure/min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
+	"@DuplojsLangDataStructure/min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
+	"@DuplojsLangDataStructure/multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
+	"@DuplojsLangDataStructure/negative-constraint": () => "Expected a number less than or equal to zero.",
+	"@DuplojsLangDataStructure/not-empty-constraint": () => "Expected a non-empty string.",
+	"@DuplojsLangDataStructure/not-zero-constraint": () => "Expected a non-zero number.",
+	"@DuplojsLangDataStructure/number-in-string-constraint": () => "Expected a string representing a number.",
+	"@DuplojsLangDataStructure/odd-constraint": () => "Expected an odd number.",
+	"@DuplojsLangDataStructure/path-constraint": () => "Expected a valid path.",
+	"@DuplojsLangDataStructure/positive-constraint": () => "Expected a number greater than or equal to zero.",
+	"@DuplojsLangDataStructure/refine-constraint": () => "Expected a value satisfying the custom refinement.",
+	"@DuplojsLangDataStructure/regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
+	"@DuplojsLangDataStructure/safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
+	"@DuplojsLangDataStructure/segment-path-constraint": () => "Expected a valid path segment.",
+	"@DuplojsLangDataStructure/strict-negative-constraint": () => "Expected a number less than zero.",
+	"@DuplojsLangDataStructure/strict-positive-constraint": () => "Expected a number greater than zero.",
+	"@DuplojsLangDataStructure/string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
+	"@DuplojsLangDataStructure/trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
+	"@DuplojsLangDataStructure/url-constraint": () => "Expected a valid URL.",
+	"@DuplojsLangDataStructure/uuid-constraint": () => "Expected a valid UUID.",
+	"@DuplojsLangModeling/entity-structure": () => "Expected a valid entity object.",
+	"@DuplojsLangModeling/new-type-structure": () => "Expected a value matching the branded type.",
+	"@DuplojsLangModeling/tagged-object-structure": (source) => `Expected a plain object matching one of the tagged variants of ${source.name}.`
 };
 const createDefaultCodecErrorMessage = (codecName, encodedValueDescription, decodedValueDescription) => (_codec, issue) => {
 	if (issue.from === "predicate") return require_base.encodeIssueKind.has(issue) ? `The ${codecName} codec must produce ${encodedValueDescription}.` : `Expected ${encodedValueDescription} for the ${codecName} codec.`;

package/dist/dataStructure/common/error/defaultInterpreter.d.ts

@@ -1,57 +1,60 @@
 import * as DString from '../../../string';
 export declare const defaultErrorInterpreterDataStructureDictionary: {
-    readonly "array-structure": () => string;
-    readonly "lazy-structure": () => string;
-    readonly "non-encodable-string-structure": (source: import('../..').NonEncodableStringStructure) => string;
-    readonly "object-structure": () => string;
-    readonly "record-structure": () => string;
-    readonly "type-structure": () => string;
-    readonly "union-structure": () => string;
-    readonly "bigint-type": () => string;
-    readonly "bigint-literal-type": (source: import('../..').BigintLiteralType<bigint>) => string;
-    readonly "boolean-type": () => string;
-    readonly "boolean-literal-type": (source: import('../..').BooleanLiteralType<boolean>) => string;
-    readonly "date-type": () => string;
-    readonly "null-type": () => string;
-    readonly "number-type": () => string;
-    readonly "number-literal-type": (source: import('../..').NumberLiteralType<number>) => string;
-    readonly "string-type": () => string;
-    readonly "string-literal-type": (source: import('../..').StringLiteralType<string>) => string;
-    readonly "time-type": () => string;
-    readonly "undefined-type": () => string;
-    readonly "absolute-path-constraint": () => string;
-    readonly "allowed-characters-constraint": (source: import('../..').AllowedCharactersConstraint<DString.CharactersRange>) => string;
-    readonly "array-length-equal-constraint": (source: import('../..').ArrayLengthEqualConstraint<number>) => string;
-    readonly "between-than-constraint": (source: import('../..').BetweenThanConstraint<number, number>) => string;
-    readonly "between-than-or-equal-constraint": (source: import('../..').BetweenThanOrEqualConstraint<number, number>) => string;
-    readonly "email-constraint": () => string;
-    readonly "even-constraint": () => string;
-    readonly "greater-than-constraint": (source: import('../..').GreaterThanConstraint<number>) => string;
-    readonly "greater-than-or-equal-constraint": (source: import('../..').GreaterThanOrEqualConstraint<number>) => string;
-    readonly "integer-constraint": () => string;
-    readonly "less-than-constraint": (source: import('../..').LessThanConstraint<number>) => string;
-    readonly "less-than-or-equal-constraint": (source: import('../..').LessThanOrEqualConstraint<number>) => string;
-    readonly "max-characters-constraint": (source: import('../..').MaxCharactersConstraint<number>) => string;
-    readonly "max-elements-constraint": (source: import('../..').MaxElementsConstraint<number>) => string;
-    readonly "min-characters-constraint": (source: import('../..').MinCharactersConstraint<number>) => string;
-    readonly "min-elements-constraint": (source: import('../..').MinElementsConstraint<number>) => string;
-    readonly "multiple-of-constraint": (source: import('../..').MultipleOfConstraint<number>) => string;
-    readonly "negative-constraint": () => string;
-    readonly "not-empty-constraint": () => string;
-    readonly "not-zero-constraint": () => string;
-    readonly "number-in-string-constraint": () => string;
-    readonly "odd-constraint": () => string;
-    readonly "path-constraint": () => string;
-    readonly "positive-constraint": () => string;
-    readonly "refine-constraint": () => string;
-    readonly "regex-constraint": (source: import('../..').RegexConstraint) => string;
-    readonly "safe-constraint": () => string;
-    readonly "segment-path-constraint": () => string;
-    readonly "strict-negative-constraint": () => string;
-    readonly "strict-positive-constraint": () => string;
-    readonly "string-length-equal-constraint": (source: import('../..').StringLengthEqualConstraint<number>) => string;
-    readonly "trimmed-constraint": () => string;
-    readonly "url-constraint": () => string;
-    readonly "uuid-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/array-structure": () => string;
+    readonly "@DuplojsLangDataStructure/lazy-structure": () => string;
+    readonly "@DuplojsLangDataStructure/non-encodable-string-structure": (source: import('../..').NonEncodableStringStructure) => string;
+    readonly "@DuplojsLangDataStructure/object-structure": () => string;
+    readonly "@DuplojsLangDataStructure/record-structure": () => string;
+    readonly "@DuplojsLangDataStructure/type-structure": () => string;
+    readonly "@DuplojsLangDataStructure/union-structure": () => string;
+    readonly "@DuplojsLangDataStructure/bigint-type": () => string;
+    readonly "@DuplojsLangDataStructure/bigint-literal-type": (source: import('../..').BigintLiteralType<bigint>) => string;
+    readonly "@DuplojsLangDataStructure/boolean-type": () => string;
+    readonly "@DuplojsLangDataStructure/boolean-literal-type": (source: import('../..').BooleanLiteralType<boolean>) => string;
+    readonly "@DuplojsLangDataStructure/date-type": () => string;
+    readonly "@DuplojsLangDataStructure/null-type": () => string;
+    readonly "@DuplojsLangDataStructure/number-type": () => string;
+    readonly "@DuplojsLangDataStructure/number-literal-type": (source: import('../..').NumberLiteralType<number>) => string;
+    readonly "@DuplojsLangDataStructure/string-type": () => string;
+    readonly "@DuplojsLangDataStructure/string-literal-type": (source: import('../..').StringLiteralType<string>) => string;
+    readonly "@DuplojsLangDataStructure/time-type": () => string;
+    readonly "@DuplojsLangDataStructure/undefined-type": () => string;
+    readonly "@DuplojsLangDataStructure/absolute-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/allowed-characters-constraint": (source: import('../..').AllowedCharactersConstraint<DString.CharactersRange>) => string;
+    readonly "@DuplojsLangDataStructure/array-length-equal-constraint": (source: import('../..').ArrayLengthEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/between-than-constraint": (source: import('../..').BetweenThanConstraint<number, number>) => string;
+    readonly "@DuplojsLangDataStructure/between-than-or-equal-constraint": (source: import('../..').BetweenThanOrEqualConstraint<number, number>) => string;
+    readonly "@DuplojsLangDataStructure/email-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/even-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/greater-than-constraint": (source: import('../..').GreaterThanConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source: import('../..').GreaterThanOrEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/integer-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/less-than-constraint": (source: import('../..').LessThanConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/less-than-or-equal-constraint": (source: import('../..').LessThanOrEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/max-characters-constraint": (source: import('../..').MaxCharactersConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/max-elements-constraint": (source: import('../..').MaxElementsConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/min-characters-constraint": (source: import('../..').MinCharactersConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/min-elements-constraint": (source: import('../..').MinElementsConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/multiple-of-constraint": (source: import('../..').MultipleOfConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/negative-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/not-empty-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/not-zero-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/number-in-string-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/odd-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/positive-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/refine-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/regex-constraint": (source: import('../..').RegexConstraint) => string;
+    readonly "@DuplojsLangDataStructure/safe-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/segment-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/strict-negative-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/strict-positive-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/string-length-equal-constraint": (source: import('../..').StringLengthEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/trimmed-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/url-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/uuid-constraint": () => string;
+    readonly "@DuplojsLangModeling/entity-structure": () => string;
+    readonly "@DuplojsLangModeling/new-type-structure": () => string;
+    readonly "@DuplojsLangModeling/tagged-object-structure": (source: import('../../../modeling').TaggedObjectStructure<import('../../../modeling').ObjectTag<string>>) => string;
 };
 export declare const defaultErrorInterpreterCodecDictionary: [[import('../..').Codec<import('../..').TheBigint, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheDate, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheTime, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheBigint, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheBoolean, "true" | "false">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheDate, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheNull, "null">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheNumber, string & DString.Number>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheTime, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheUndefined, "undefined">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string]];

package/dist/dataStructure/common/error/defaultInterpreter.mjs

@@ -7,59 +7,62 @@ import { codecsString } from "../codec/defaults/string.mjs";
 import { encodeIssueKind } from "./base.mjs";
 //#region scripts/dataStructure/common/error/defaultInterpreter.ts
 const defaultErrorInterpreterDataStructureDictionary = {
-	"array-structure": () => "Expected an array.",
-	"lazy-structure": () => "Expected a value matching the resolved structure.",
-	"non-encodable-string-structure": (source) => `Expected ${stringify(source.definition.value)}.`,
-	"object-structure": () => "Expected a plain object containing only the defined properties.",
-	"record-structure": () => "Expected a plain object matching the record definition.",
-	"type-structure": () => "Expected a value matching the configured type.",
-	"union-structure": () => "Expected a value matching at least one union member.",
-	"bigint-type": () => "Expected a bigint.",
-	"bigint-literal-type": (source) => `Expected ${to(source.definition.value)}n.`,
-	"boolean-type": () => "Expected a boolean.",
-	"boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
-	"date-type": () => "Expected a DuploJS date.",
-	"null-type": () => "Expected null.",
-	"number-type": () => "Expected a finite number.",
-	"number-literal-type": (source) => `Expected ${source.definition.value}.`,
-	"string-type": () => "Expected a string.",
-	"string-literal-type": (source) => `Expected ${stringify(source.definition.value)}.`,
-	"time-type": () => "Expected a DuploJS time.",
-	"undefined-type": () => "Expected undefined.",
-	"absolute-path-constraint": () => "Expected an absolute path.",
-	"allowed-characters-constraint": (source) => `Expected a string containing only characters from ${join(coalescing(source.definition.charactersRange), ", ")}.`,
-	"array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
-	"between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
-	"between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
-	"email-constraint": () => "Expected a valid email address.",
-	"even-constraint": () => "Expected an even number.",
-	"greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
-	"greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
-	"integer-constraint": () => "Expected an integer.",
-	"less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
-	"less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
-	"max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
-	"max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
-	"min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
-	"min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
-	"multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
-	"negative-constraint": () => "Expected a number less than or equal to zero.",
-	"not-empty-constraint": () => "Expected a non-empty string.",
-	"not-zero-constraint": () => "Expected a non-zero number.",
-	"number-in-string-constraint": () => "Expected a string representing a number.",
-	"odd-constraint": () => "Expected an odd number.",
-	"path-constraint": () => "Expected a valid path.",
-	"positive-constraint": () => "Expected a number greater than or equal to zero.",
-	"refine-constraint": () => "Expected a value satisfying the custom refinement.",
-	"regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
-	"safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
-	"segment-path-constraint": () => "Expected a valid path segment.",
-	"strict-negative-constraint": () => "Expected a number less than zero.",
-	"strict-positive-constraint": () => "Expected a number greater than zero.",
-	"string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
-	"trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
-	"url-constraint": () => "Expected a valid URL.",
-	"uuid-constraint": () => "Expected a valid UUID."
+	"@DuplojsLangDataStructure/array-structure": () => "Expected an array.",
+	"@DuplojsLangDataStructure/lazy-structure": () => "Expected a value matching the resolved structure.",
+	"@DuplojsLangDataStructure/non-encodable-string-structure": (source) => `Expected ${stringify(source.definition.value)}.`,
+	"@DuplojsLangDataStructure/object-structure": () => "Expected a plain object containing only the defined properties.",
+	"@DuplojsLangDataStructure/record-structure": () => "Expected a plain object matching the record definition.",
+	"@DuplojsLangDataStructure/type-structure": () => "Expected a value matching the configured type.",
+	"@DuplojsLangDataStructure/union-structure": () => "Expected a value matching at least one union member.",
+	"@DuplojsLangDataStructure/bigint-type": () => "Expected a bigint.",
+	"@DuplojsLangDataStructure/bigint-literal-type": (source) => `Expected ${to(source.definition.value)}n.`,
+	"@DuplojsLangDataStructure/boolean-type": () => "Expected a boolean.",
+	"@DuplojsLangDataStructure/boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"@DuplojsLangDataStructure/date-type": () => "Expected a DuploJS date.",
+	"@DuplojsLangDataStructure/null-type": () => "Expected null.",
+	"@DuplojsLangDataStructure/number-type": () => "Expected a finite number.",
+	"@DuplojsLangDataStructure/number-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"@DuplojsLangDataStructure/string-type": () => "Expected a string.",
+	"@DuplojsLangDataStructure/string-literal-type": (source) => `Expected ${stringify(source.definition.value)}.`,
+	"@DuplojsLangDataStructure/time-type": () => "Expected a DuploJS time.",
+	"@DuplojsLangDataStructure/undefined-type": () => "Expected undefined.",
+	"@DuplojsLangDataStructure/absolute-path-constraint": () => "Expected an absolute path.",
+	"@DuplojsLangDataStructure/allowed-characters-constraint": (source) => `Expected a string containing only characters from ${join(coalescing(source.definition.charactersRange), ", ")}.`,
+	"@DuplojsLangDataStructure/array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
+	"@DuplojsLangDataStructure/between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
+	"@DuplojsLangDataStructure/between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
+	"@DuplojsLangDataStructure/email-constraint": () => "Expected a valid email address.",
+	"@DuplojsLangDataStructure/even-constraint": () => "Expected an even number.",
+	"@DuplojsLangDataStructure/greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/integer-constraint": () => "Expected an integer.",
+	"@DuplojsLangDataStructure/less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
+	"@DuplojsLangDataStructure/max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
+	"@DuplojsLangDataStructure/min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
+	"@DuplojsLangDataStructure/min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
+	"@DuplojsLangDataStructure/multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
+	"@DuplojsLangDataStructure/negative-constraint": () => "Expected a number less than or equal to zero.",
+	"@DuplojsLangDataStructure/not-empty-constraint": () => "Expected a non-empty string.",
+	"@DuplojsLangDataStructure/not-zero-constraint": () => "Expected a non-zero number.",
+	"@DuplojsLangDataStructure/number-in-string-constraint": () => "Expected a string representing a number.",
+	"@DuplojsLangDataStructure/odd-constraint": () => "Expected an odd number.",
+	"@DuplojsLangDataStructure/path-constraint": () => "Expected a valid path.",
+	"@DuplojsLangDataStructure/positive-constraint": () => "Expected a number greater than or equal to zero.",
+	"@DuplojsLangDataStructure/refine-constraint": () => "Expected a value satisfying the custom refinement.",
+	"@DuplojsLangDataStructure/regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
+	"@DuplojsLangDataStructure/safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
+	"@DuplojsLangDataStructure/segment-path-constraint": () => "Expected a valid path segment.",
+	"@DuplojsLangDataStructure/strict-negative-constraint": () => "Expected a number less than zero.",
+	"@DuplojsLangDataStructure/strict-positive-constraint": () => "Expected a number greater than zero.",
+	"@DuplojsLangDataStructure/string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
+	"@DuplojsLangDataStructure/trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
+	"@DuplojsLangDataStructure/url-constraint": () => "Expected a valid URL.",
+	"@DuplojsLangDataStructure/uuid-constraint": () => "Expected a valid UUID.",
+	"@DuplojsLangModeling/entity-structure": () => "Expected a valid entity object.",
+	"@DuplojsLangModeling/new-type-structure": () => "Expected a value matching the branded type.",
+	"@DuplojsLangModeling/tagged-object-structure": (source) => `Expected a plain object matching one of the tagged variants of ${source.name}.`
 };
 const createDefaultCodecErrorMessage = (codecName, encodedValueDescription, decodedValueDescription) => (_codec, issue) => {
 	if (issue.from === "predicate") return encodeIssueKind.has(issue) ? `The ${codecName} codec must produce ${encodedValueDescription}.` : `Expected ${encodedValueDescription} for the ${codecName} codec.`;

package/dist/dataStructure/common/error/interpreter.cjs

@@ -6,9 +6,8 @@ const require_reduce = require("../../../array/reduce.cjs");
 const require_pipe = require("../../../common/pipe.cjs");
 const require_base$1 = require("./base.cjs");
 //#region scripts/dataStructure/common/error/interpreter.ts
-const kindNamespaceName = "DuplojsLangDataStructure";
 function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
-	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}${key}`, value)));
 	const getInterpretedMessageStructure = (structure, issue) => require_reduce.reduce(formattedStructureDictionary, require_reduce.reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure, issue)) : next(void 0));
 	const getInterpretedMessageCodec = (codec, issue) => require_reduce.reduce(codecDictionary, require_reduce.reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message(codec, issue)) : next(void 0));
 	return (error) => require_map.map(error.issues, (issue) => {

package/dist/dataStructure/common/error/interpreter.d.ts

@@ -1,13 +1,10 @@
 import { Structure, Structures } from '../../structure';
-import { createKind } from '../../kind';
 import { Type, Types } from '../../type';
 import { Constraint, Constraints } from '../../constraint';
 import { Error, DecodeIssue, EncodeIssue, Issue } from './base';
 import { Codec } from '../codec';
 import * as DKind from '../../../kind';
 import * as DCommon from '../../../common';
-declare const kindNamespaceName: DKind.GetNamespaceName<typeof createKind>;
-type RemoveNamespace<GenericString> = GenericString extends `@${typeof kindNamespaceName}/${infer InferredKindName}` ? InferredKindName : never;
 export interface InterpretedMessage {
     source?: string;
     interpretedSource?: string;
@@ -25,12 +22,11 @@ export interface InterpretedDecodedIssue extends DecodeIssue {
 }
 export type InterpretedIssues = (InterpretedIssue | InterpretedEncodedIssue | InterpretedDecodedIssue);
 export type StructureDictionaryParams = DCommon.SimplifyTopLevel<Omit<{
-    [DataStructure in (Types | Structures | Constraints) as RemoveNamespace<DKind.GetName<DataStructure>>]?: (structure: DataStructure, issue: Issue) => string;
-}, RemoveNamespace<DKind.GetName<Type>> | RemoveNamespace<DKind.GetName<Structure>> | RemoveNamespace<DKind.GetName<Constraint>>>>;
+    [DataStructure in (Types | Structures | Constraints) as DKind.GetName<DataStructure>]?: (structure: DataStructure, issue: Issue) => string;
+}, DKind.GetName<Type> | DKind.GetName<Structure> | DKind.GetName<Constraint>>>;
 export type CodecDictionaryParams = [
     Codec,
     (codec: Codec, issue: EncodeIssue | DecodeIssue) => string
 ][];
 export declare function createErrorInterpreter(structureDictionary?: StructureDictionaryParams, codecDictionary?: CodecDictionaryParams): (error: Error) => readonly InterpretedIssues[];
 export type ErrorInterpreter = ReturnType<typeof createErrorInterpreter>;
-export {};

package/dist/dataStructure/common/error/interpreter.mjs

@@ -6,9 +6,8 @@ import { reduce, reduceFrom } from "../../../array/reduce.mjs";
 import { pipe } from "../../../common/pipe.mjs";
 import { encodeIssueKind, issueKind } from "./base.mjs";
 //#region scripts/dataStructure/common/error/interpreter.ts
-const kindNamespaceName = "DuplojsLangDataStructure";
 function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
-	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}${key}`, value)));
 	const getInterpretedMessageStructure = (structure, issue) => reduce(formattedStructureDictionary, reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure, issue)) : next(void 0));
 	const getInterpretedMessageCodec = (codec, issue) => reduce(codecDictionary, reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message(codec, issue)) : next(void 0));
 	return (error) => map(error.issues, (issue) => {

package/package.json

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