@duplojs/lang 0.0.1-beta.8 → 0.0.1-beta.9

package/dist/chrono/createDate.cjs

@@ -3,8 +3,8 @@ const require_theDate = require("./theDate.cjs");
 const require_isDate = require("./isDate.cjs");
 const require_create = require("../either/left/create.cjs");
 const require_is = require("../either/left/is.cjs");
-const require_when = require("../either/left/when.cjs");
 const require_create$1 = require("../either/right/create.cjs");
+const require_when = require("../either/left/when.cjs");
 const require_unwrap = require("../either/right/unwrap.cjs");
 const require_safeCallback = require("../either/safeCallback.cjs");
 const require_isSafeTimestamp = require("./isSafeTimestamp.cjs");

package/dist/chrono/createDate.mjs

@@ -3,8 +3,8 @@ import { TheDate } from "./theDate.mjs";
 import { isDate } from "./isDate.mjs";
 import { left } from "../either/left/create.mjs";
 import { isLeft } from "../either/left/is.mjs";
-import { whenIsLeft } from "../either/left/when.mjs";
 import { right } from "../either/right/create.mjs";
+import { whenIsLeft } from "../either/left/when.mjs";
 import { unwrapRight } from "../either/right/unwrap.mjs";
 import { safeCallback } from "../either/safeCallback.mjs";
 import { isSafeTimestamp } from "./isSafeTimestamp.mjs";

package/dist/common/constraint/cast/index.d.ts

@@ -3,7 +3,7 @@ import { UnbundlesConstraint, BaseConstraint, RemoveConstraint } from '../types'
 import { CastError, RemoveCastError } from './error';
 import { ComputeCastConstraintNumberRule } from './number';
 import { ComputeCastConstraintStringRule } from './string';
-import { AnyTuple, IsExtends, BreakGenericLink, NeverCoalescing, UnionContain, IsEqual } from '../../types';
+import { IsExtends, BreakGenericLink, NeverCoalescing, UnionContain, IsEqual } from '../../types';
 import type * as DArray from '../../../array';
 import type * as DTuple from '../../../tuple';
 import type * as DObject from '../../../object';
@@ -17,7 +17,7 @@ export interface ComputeCastConstraintRule<GenericValue extends unknown, Generic
     array: GenericValue extends readonly unknown[] ? DObject.Values<ComputeCastConstraintArrayRule<GenericValue, GenericConstraint>> : never;
 }
 export type ComputeCastConstraint<GenericValue extends unknown, GenericExpectedValue extends unknown> = (GenericExpectedValue extends any ? [UnbundlesConstraint<GenericExpectedValue>] : never) extends infer InferredComputedExpectedValue extends [BaseConstraint] ? DArray.Unwrap<NeverCoalescing<Extract<GenericValue extends any ? (InferredComputedExpectedValue extends [infer InferredConstraint extends BaseConstraint] ? NeverCoalescing<Extract<InferredConstraint extends any ? [
-    NeverCoalescing<DObject.Values<ComputeCastConstraintRule<GenericValue, InferredConstraint>>, CastError<"None of the intended constraints is possible on the current value.", GenericValue, InferredConstraint>>
+    GenericValue extends InferredConstraint ? unknown : NeverCoalescing<DObject.Values<ComputeCastConstraintRule<GenericValue, InferredConstraint>>, CastError<"None of the intended constraints is possible on the current value.", GenericValue, InferredConstraint>>
 ] : never, [
     CastError<any, any, any>
 ]>, [
@@ -25,7 +25,7 @@ export type ComputeCastConstraint<GenericValue extends unknown, GenericExpectedV
 ]> : never) extends infer InferredResult ? UnionContain<InferredResult, [unknown]> extends true ? [unknown] : InferredResult : never : never, [
     CastError<any, any, any>
 ]>, unknown>> : never;
-type ComputeTransformCastValue<GenericValue extends unknown> = GenericValue extends (string | number | AnyTuple) ? RemoveConstraint<GenericValue> : GenericValue extends readonly unknown[] ? DArray.ExtractLengthEqual<GenericValue, unknown> extends DArray.LengthEqual<infer InferredLength> ? DTuple.Create<GenericValue[number], InferredLength> : DArray.ExtractMinElements<GenericValue, unknown> extends DArray.MinElements<infer InferredMin> ? readonly [...DTuple.Create<GenericValue[number], InferredMin>, ...GenericValue] : RemoveConstraint<GenericValue> : never;
+type ComputeTransformCastValue<GenericValue extends unknown> = GenericValue extends readonly unknown[] ? DArray.ExtractLengthEqual<GenericValue, unknown> extends DArray.LengthEqual<infer InferredLength> ? DTuple.Create<GenericValue[number], InferredLength> : DArray.ExtractMinElements<GenericValue, unknown> extends DArray.MinElements<infer InferredMin> ? readonly [...DTuple.Create<GenericValue[number], InferredMin>, ...GenericValue] : RemoveConstraint<GenericValue> : RemoveConstraint<GenericValue>;
 export type ComputeCastValue<GenericValue extends unknown, GenericExpectedValue extends unknown> = [
     ComputeTransformCastValue<GenericValue>,
     ComputeTransformCastValue<GenericExpectedValue>

package/dist/common/constraint/infer/string.d.ts

@@ -5,6 +5,7 @@ export interface ComputeInferConstraintStringRule<GenericInput extends string, G
     maxCharacters: DString.ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never;
     minCharacters: DString.ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never;
     lengthEqual: DString.ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never;
+    allowedCharacters: GenericOutput extends DString.AllowedCharacters ? keyof ReturnType<GenericOutput[DCommon.ConstraintSymbol][DString.AllowedCharactersConstraintName]> extends infer InferredCharactersRange extends DString.CharactersRange ? DString.IsAllowedString<GenericInput, DString.CharactersRangeStore[InferredCharactersRange]> extends true ? DString.AllowedCharacters<InferredCharactersRange> : DCommon.ComputedTypeError<`Impossible to cast on AllowedCharacters because value ${GenericInput} contains forbidden characters.`> : never : never;
     number: DCommon.IsExtends<GenericOutput, DString.Number> extends true ? GenericInput extends DString.NumberInString ? DString.Number : DCommon.ComputedTypeError<`Impossible to cast on Number because value ${GenericInput} is not a number.`> : never;
     path: DCommon.IsExtends<GenericOutput, DPath.Path> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
     absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on AbsolutePath because value ${GenericInput} is not absolute path.`> : never;

package/dist/common/types/index.d.ts

@@ -26,6 +26,7 @@ export type * from './forward';
 export type * from './hasSomething';
 export type * from './isEqual';
 export type * from './isNever';
+export type * from './isObject';
 export type * from './isUnion';
 export type * from './json';
 export type * from './lastUnionElement';

package/dist/common/types/isObject.d.ts

@@ -0,0 +1,8 @@
+import { And } from './and';
+import { IsExtends } from './IsExtends';
+import { IsNever } from './isNever';
+import { Not } from './not';
+export type IsObject<GenericValue extends unknown> = And<[
+    IsExtends<GenericValue, object>,
+    Not<IsNever<keyof GenericValue>>
+]>;

package/dist/dataStructure/common/codec/base.cjs

@@ -9,8 +9,8 @@ function createCodec(fundamentalType, predicateEncode, encode, decode) {
 	const self = {
 		fundamentalType,
 		predicateEncode: (data) => predicateEncode(data),
-		encode: (data, errorHandler) => require_callThen.callThen(encode(data, self, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? require_resultSymbol.ErrorSymbol : encodedData)),
-		decode: (data, errorHandler) => require_callThen.callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? require_resultSymbol.ErrorSymbol : decode(data, self, errorHandler)),
+		encode: (data, errorHandler) => require_callThen.callThen(encode(data, self, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? errorHandler?.().addEncodeIssue(self, "encoding", data) ?? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, "predicate", encodedData) ?? require_resultSymbol.ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => require_callThen.callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, "predicate", data) ?? require_resultSymbol.ErrorSymbol : require_callThen.callThen(decode(data, self, errorHandler), (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? errorHandler?.().addDecodeIssue(self, "decoding", data) ?? require_resultSymbol.ErrorSymbol : decodedData)),
 		[codecKind.runTimeKey]: null
 	};
 	return self;

package/dist/dataStructure/common/codec/base.mjs

@@ -9,8 +9,8 @@ function createCodec(fundamentalType, predicateEncode, encode, decode) {
 	const self = {
 		fundamentalType,
 		predicateEncode: (data) => predicateEncode(data),
-		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? ErrorSymbol : encodedData)),
-		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? ErrorSymbol : decode(data, self, errorHandler)),
+		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? errorHandler?.().addEncodeIssue(self, "encoding", data) ?? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, "predicate", encodedData) ?? ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, "predicate", data) ?? ErrorSymbol : callThen(decode(data, self, errorHandler), (decodedData) => decodedData === ErrorSymbol ? errorHandler?.().addDecodeIssue(self, "decoding", data) ?? ErrorSymbol : decodedData)),
 		[codecKind.runTimeKey]: null
 	};
 	return self;

package/dist/dataStructure/common/error.cjs

@@ -34,8 +34,9 @@ function createErrorHandler(defaultPath) {
 				[issueKind.runTimeKey]: null
 			});
 		},
-		addEncodeIssue: (source, data, message) => {
+		addEncodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,
@@ -43,8 +44,9 @@ function createErrorHandler(defaultPath) {
 				[encodeIssueKind.runTimeKey]: null
 			});
 		},
-		addDecodeIssue: (source, data, message) => {
+		addDecodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,

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

@@ -13,6 +13,7 @@ export interface Issue extends DKind.Kind<typeof issueKind> {
 }
 export declare const encodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/encode-issue", unknown>>;
 export interface EncodeIssue extends DKind.Kind<typeof encodeIssueKind> {
+    readonly from: "encoding" | "predicate" | "external";
     readonly path: string;
     readonly data: unknown;
     readonly message?: string;
@@ -20,6 +21,7 @@ export interface EncodeIssue extends DKind.Kind<typeof encodeIssueKind> {
 }
 export declare const decodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/decode-issue", unknown>>;
 export interface DecodeIssue extends DKind.Kind<typeof decodeIssueKind> {
+    readonly from: "decoding" | "predicate" | "external";
     readonly path: string;
     readonly data: unknown;
     readonly message?: string;
@@ -37,8 +39,8 @@ export interface ErrorHandler {
     readonly issues: readonly Issues[];
     readonly currentPath: string[];
     addIssue(source: ReturnType<Issue["getSource"]>, data: unknown, subSource?: ReturnType<Extract<Issue["getSubSource"], DCommon.AnyFunction>>): void;
-    addEncodeIssue(source: ReturnType<EncodeIssue["getSource"]>, data: unknown, message?: string): void;
-    addDecodeIssue(source: ReturnType<DecodeIssue["getSource"]>, data: unknown, message?: string): void;
+    addEncodeIssue(source: ReturnType<EncodeIssue["getSource"]>, from: EncodeIssue["from"], data: unknown, message?: string): void;
+    addDecodeIssue(source: ReturnType<DecodeIssue["getSource"]>, from: DecodeIssue["from"], data: unknown, message?: string): void;
     importIssues(errorHandler: (GetErrorHandler | ErrorHandler)[]): void;
     createPathStage(): PathStageErrorHandler;
     createError(): Error;

package/dist/dataStructure/common/error.mjs

@@ -34,8 +34,9 @@ function createErrorHandler(defaultPath) {
 				[issueKind.runTimeKey]: null
 			});
 		},
-		addEncodeIssue: (source, data, message) => {
+		addEncodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,
@@ -43,8 +44,9 @@ function createErrorHandler(defaultPath) {
 				[encodeIssueKind.runTimeKey]: null
 			});
 		},
-		addDecodeIssue: (source, data, message) => {
+		addDecodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,

package/dist/dataStructure/common/errorInterpreter.cjs

@@ -9,8 +9,8 @@ const require_error = require("./error.cjs");
 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 getInterpretedMessageStructure = (structure) => require_reduce.reduce(formattedStructureDictionary, require_reduce.reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure)) : next(void 0));
-	const getInterpretedMessageCodec = (codec) => require_reduce.reduce(codecDictionary, require_reduce.reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message) : next(void 0));
+	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) => {
 		if (require_error.issueKind.has(issue)) {
 			const source = issue.getSource();
@@ -20,8 +20,8 @@ function createErrorInterpreter(structureDictionary = {}, codecDictionary = [])
 				interpretedMessage: {
 					source: source.definition.message,
 					subSource: subSource?.definition.message,
-					interpretedSource: getInterpretedMessageStructure(source),
-					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource)
+					interpretedSource: getInterpretedMessageStructure(source, issue),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource, issue)
 				}
 			};
 		}
@@ -29,14 +29,14 @@ function createErrorInterpreter(structureDictionary = {}, codecDictionary = [])
 			...issue,
 			interpretedMessage: {
 				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
 			}
 		};
 		return {
 			...issue,
 			interpretedMessage: {
 				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
 			}
 		};
 	});

package/dist/dataStructure/common/errorInterpreter.d.ts

@@ -24,9 +24,13 @@ export interface InterpretedDecodedIssue extends DecodeIssue {
     interpretedMessage: InterpretedMessage;
 }
 export type InterpretedIssues = (InterpretedIssue | InterpretedEncodedIssue | InterpretedDecodedIssue);
-type CreateDictionaryParams = DCommon.SimplifyTopLevel<Omit<{
-    [DataStructure in (Types | Structures | Constraints) as RemoveNamespace<DKind.GetName<DataStructure>>]?: (structure: DataStructure) => string;
+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>>>>;
-export declare function createErrorInterpreter(structureDictionary?: CreateDictionaryParams, codecDictionary?: [Codec, string][]): (error: Error) => readonly InterpretedIssues[];
+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/errorInterpreter.mjs

@@ -9,8 +9,8 @@ import { encodeIssueKind, issueKind } from "./error.mjs";
 const kindNamespaceName = "DuplojsLangDataStructure";
 function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
 	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
-	const getInterpretedMessageStructure = (structure) => reduce(formattedStructureDictionary, reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure)) : next(void 0));
-	const getInterpretedMessageCodec = (codec) => reduce(codecDictionary, reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message) : next(void 0));
+	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) => {
 		if (issueKind.has(issue)) {
 			const source = issue.getSource();
@@ -20,8 +20,8 @@ function createErrorInterpreter(structureDictionary = {}, codecDictionary = [])
 				interpretedMessage: {
 					source: source.definition.message,
 					subSource: subSource?.definition.message,
-					interpretedSource: getInterpretedMessageStructure(source),
-					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource)
+					interpretedSource: getInterpretedMessageStructure(source, issue),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource, issue)
 				}
 			};
 		}
@@ -29,14 +29,14 @@ function createErrorInterpreter(structureDictionary = {}, codecDictionary = [])
 			...issue,
 			interpretedMessage: {
 				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
 			}
 		};
 		return {
 			...issue,
 			interpretedMessage: {
 				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
 			}
 		};
 	});

package/dist/dataStructure/constraint/defaults/allowedCharacters.d.ts

@@ -3,11 +3,9 @@ import type * as DCommon from '../../../common';
 import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const allowedCharactersConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/allowed-characters-constraint", unknown>>;
-type AllowedCharactersConstraintValue<GenericCharactersRange extends DString.CharactersRange> = string & DCommon.UnionToIntersection<GenericCharactersRange extends any ? DString.AllowedCharacters<GenericCharactersRange> : never>;
 export interface AllowedCharactersConstraintDefinition<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends ConstraintDefinition {
     readonly charactersRange: DCommon.MaybeArray<GenericCharactersRange>;
 }
-export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.Forward<Constraint<string, AllowedCharactersConstraintValue<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
+export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.Forward<Constraint<string, string & DString.AllowedCharacters<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
 }
 export declare const AllowedCharactersConstraint: <GenericCharactersRange extends DString.CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>) => AllowedCharactersConstraint<GenericCharactersRange>;
-export {};

package/dist/dataStructure/helpers/index.d.ts

@@ -14,6 +14,8 @@ export * from './greaterThan';
 export * from './greaterThanOrEqual';
 export * from './integer';
 export * from './isNullStructure';
+export * from './isNullable';
+export * from './isOptional';
 export * from './isUndefinedStructure';
 export * from './lazy';
 export * from './lessThan';
@@ -39,17 +41,18 @@ export * from './path';
 export * from './positive';
 export * from './record';
 export * from './refine';
+export * from './regex';
 export * from './required';
 export * from './safe';
 export * from './segmentPath';
-export * from './string';
 export * from './strictNegative';
 export * from './strictPositive';
+export * from './string';
 export * from './stringLengthEqual';
 export * from './time';
 export * from './trimmed';
 export * from './undefined';
 export * from './union';
+export * from './unwrapLazy';
 export * from './url';
 export * from './uuid';
-export * from './regex';

package/dist/dataStructure/helpers/isNullable.cjs

@@ -0,0 +1,12 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
+const require_union = require("../structure/defaults/union.cjs");
+const require_isNullStructure = require("./isNullStructure.cjs");
+//#region scripts/dataStructure/helpers/isNullable.ts
+function isNullable(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return isNullable(structure.definition.getter.value);
+	if (!require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return require_isNullStructure.isNullStructure(structure);
+	return structure.definition.values.value.some(require_isNullStructure.isNullStructure);
+}
+//#endregion
+exports.isNullable = isNullable;

package/dist/dataStructure/helpers/isNullable.d.ts

@@ -0,0 +1,2 @@
+import { Structure } from '../structure';
+export declare function isNullable(structure: Structure): boolean;

package/dist/dataStructure/helpers/isNullable.mjs

@@ -0,0 +1,12 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
+import { unionStructureKind } from "../structure/defaults/union.mjs";
+import { isNullStructure } from "./isNullStructure.mjs";
+//#region scripts/dataStructure/helpers/isNullable.ts
+function isNullable(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return isNullable(structure.definition.getter.value);
+	if (!structureIdentifier(structure, unionStructureKind)) return isNullStructure(structure);
+	return structure.definition.values.value.some(isNullStructure);
+}
+//#endregion
+export { isNullable };

package/dist/dataStructure/helpers/isOptional.cjs

@@ -0,0 +1,12 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
+const require_union = require("../structure/defaults/union.cjs");
+const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+//#region scripts/dataStructure/helpers/isOptional.ts
+function isOptional(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return isOptional(structure.definition.getter.value);
+	if (!require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return require_isUndefinedStructure.isUndefinedStructure(structure);
+	return structure.definition.values.value.some(require_isUndefinedStructure.isUndefinedStructure);
+}
+//#endregion
+exports.isOptional = isOptional;

package/dist/dataStructure/helpers/isOptional.d.ts

@@ -0,0 +1,2 @@
+import { Structure } from '../structure';
+export declare function isOptional(structure: Structure): boolean;

package/dist/dataStructure/helpers/isOptional.mjs

@@ -0,0 +1,12 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
+import { unionStructureKind } from "../structure/defaults/union.mjs";
+import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+//#region scripts/dataStructure/helpers/isOptional.ts
+function isOptional(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return isOptional(structure.definition.getter.value);
+	if (!structureIdentifier(structure, unionStructureKind)) return isUndefinedStructure(structure);
+	return structure.definition.values.value.some(isUndefinedStructure);
+}
+//#endregion
+export { isOptional };

package/dist/dataStructure/helpers/unwrapLazy.cjs

@@ -0,0 +1,9 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
+//#region scripts/dataStructure/helpers/unwrapLazy.ts
+function unwrapLazy(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return structure.definition.getter.value;
+	return structure;
+}
+//#endregion
+exports.unwrapLazy = unwrapLazy;

package/dist/dataStructure/helpers/unwrapLazy.d.ts

@@ -0,0 +1,2 @@
+import { Structure, StructureValue } from '../structure';
+export declare function unwrapLazy<GenericStructure extends Structure>(structure: GenericStructure): Structure<StructureValue<GenericStructure>>;

package/dist/dataStructure/helpers/unwrapLazy.mjs

@@ -0,0 +1,9 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
+//#region scripts/dataStructure/helpers/unwrapLazy.ts
+function unwrapLazy(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return structure.definition.getter.value;
+	return structure;
+}
+//#endregion
+export { unwrapLazy };

package/dist/dataStructure/index.cjs

@@ -91,7 +91,9 @@ const require_greaterThan$1 = require("./helpers/greaterThan.cjs");
 const require_greaterThanOrEqual$1 = require("./helpers/greaterThanOrEqual.cjs");
 const require_integer$1 = require("./helpers/integer.cjs");
 const require_isNullStructure = require("./helpers/isNullStructure.cjs");
+const require_isNullable = require("./helpers/isNullable.cjs");
 const require_isUndefinedStructure = require("./helpers/isUndefinedStructure.cjs");
+const require_isOptional = require("./helpers/isOptional.cjs");
 const require_lazy$1 = require("./helpers/lazy.cjs");
 const require_lessThan$1 = require("./helpers/lessThan.cjs");
 const require_lessThanOrEqual$1 = require("./helpers/lessThanOrEqual.cjs");
@@ -118,18 +120,19 @@ const require_path$1 = require("./helpers/path.cjs");
 const require_positive$1 = require("./helpers/positive.cjs");
 const require_record$1 = require("./helpers/record.cjs");
 const require_refine$1 = require("./helpers/refine.cjs");
+const require_regex$1 = require("./helpers/regex.cjs");
 const require_required = require("./helpers/required.cjs");
 const require_safe$1 = require("./helpers/safe.cjs");
 const require_segmentPath$1 = require("./helpers/segmentPath.cjs");
-const require_string$3 = require("./helpers/string.cjs");
 const require_strictNegative$1 = require("./helpers/strictNegative.cjs");
 const require_strictPositive$1 = require("./helpers/strictPositive.cjs");
+const require_string$3 = require("./helpers/string.cjs");
 const require_stringLengthEqual$1 = require("./helpers/stringLengthEqual.cjs");
 const require_time$2 = require("./helpers/time.cjs");
 const require_trimmed$1 = require("./helpers/trimmed.cjs");
+const require_unwrapLazy = require("./helpers/unwrapLazy.cjs");
 const require_url$1 = require("./helpers/url.cjs");
 const require_uuid$1 = require("./helpers/uuid.cjs");
-const require_regex$1 = require("./helpers/regex.cjs");
 //#region scripts/dataStructure/index.ts
 var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	AbsolutePathConstraint: () => require_absolutePath.AbsolutePathConstraint,
@@ -252,6 +255,8 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	integer: () => require_integer$1.integer,
 	integerConstraintKind: () => require_integer.integerConstraintKind,
 	isNullStructure: () => require_isNullStructure.isNullStructure,
+	isNullable: () => require_isNullable.isNullable,
+	isOptional: () => require_isOptional.isOptional,
 	isUndefinedStructure: () => require_isUndefinedStructure.isUndefinedStructure,
 	issueKind: () => require_error.issueKind,
 	lazy: () => require_lazy$1.lazy,
@@ -334,6 +339,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	undefinedTypeKind: () => require_undefined$1.undefinedTypeKind,
 	union: () => require_union$1.union,
 	unionStructureKind: () => require_union.unionStructureKind,
+	unwrapLazy: () => require_unwrapLazy.unwrapLazy,
 	url: () => require_url$1.url,
 	urlConstraintKind: () => require_url.urlConstraintKind,
 	uuid: () => require_uuid$1.uuid,
@@ -466,6 +472,8 @@ exports.greaterThanOrEqualConstraintKind = require_greaterThanOrEqual.greaterTha
 exports.integer = require_integer$1.integer;
 exports.integerConstraintKind = require_integer.integerConstraintKind;
 exports.isNullStructure = require_isNullStructure.isNullStructure;
+exports.isNullable = require_isNullable.isNullable;
+exports.isOptional = require_isOptional.isOptional;
 exports.isUndefinedStructure = require_isUndefinedStructure.isUndefinedStructure;
 exports.issueKind = require_error.issueKind;
 exports.lazy = require_lazy$1.lazy;
@@ -548,6 +556,7 @@ exports.undefinedFundamentalTypeKind = require_undefined.undefinedFundamentalTyp
 exports.undefinedTypeKind = require_undefined$1.undefinedTypeKind;
 exports.union = require_union$1.union;
 exports.unionStructureKind = require_union.unionStructureKind;
+exports.unwrapLazy = require_unwrapLazy.unwrapLazy;
 exports.url = require_url$1.url;
 exports.urlConstraintKind = require_url.urlConstraintKind;
 exports.uuid = require_uuid$1.uuid;

package/dist/dataStructure/index.mjs

@@ -91,7 +91,9 @@ import { greaterThan } from "./helpers/greaterThan.mjs";
 import { greaterThanOrEqual } from "./helpers/greaterThanOrEqual.mjs";
 import { integer } from "./helpers/integer.mjs";
 import { isNullStructure } from "./helpers/isNullStructure.mjs";
+import { isNullable } from "./helpers/isNullable.mjs";
 import { isUndefinedStructure } from "./helpers/isUndefinedStructure.mjs";
+import { isOptional } from "./helpers/isOptional.mjs";
 import { lazy } from "./helpers/lazy.mjs";
 import { lessThan } from "./helpers/lessThan.mjs";
 import { lessThanOrEqual } from "./helpers/lessThanOrEqual.mjs";
@@ -118,18 +120,19 @@ import { path } from "./helpers/path.mjs";
 import { positive } from "./helpers/positive.mjs";
 import { record } from "./helpers/record.mjs";
 import { refine } from "./helpers/refine.mjs";
+import { regex } from "./helpers/regex.mjs";
 import { required } from "./helpers/required.mjs";
 import { safe } from "./helpers/safe.mjs";
 import { segmentPath } from "./helpers/segmentPath.mjs";
-import { string } from "./helpers/string.mjs";
 import { strictNegative } from "./helpers/strictNegative.mjs";
 import { strictPositive } from "./helpers/strictPositive.mjs";
+import { string } from "./helpers/string.mjs";
 import { stringLengthEqual } from "./helpers/stringLengthEqual.mjs";
 import { time } from "./helpers/time.mjs";
 import { trimmed } from "./helpers/trimmed.mjs";
+import { unwrapLazy } from "./helpers/unwrapLazy.mjs";
 import { url } from "./helpers/url.mjs";
 import { uuid } from "./helpers/uuid.mjs";
-import { regex } from "./helpers/regex.mjs";
 //#region scripts/dataStructure/index.ts
 var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	AbsolutePathConstraint: () => AbsolutePathConstraint,
@@ -252,6 +255,8 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	integer: () => integer,
 	integerConstraintKind: () => integerConstraintKind,
 	isNullStructure: () => isNullStructure,
+	isNullable: () => isNullable,
+	isOptional: () => isOptional,
 	isUndefinedStructure: () => isUndefinedStructure,
 	issueKind: () => issueKind,
 	lazy: () => lazy,
@@ -334,10 +339,11 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	undefinedTypeKind: () => undefinedTypeKind,
 	union: () => union,
 	unionStructureKind: () => unionStructureKind,
+	unwrapLazy: () => unwrapLazy,
 	url: () => url,
 	urlConstraintKind: () => urlConstraintKind,
 	uuid: () => uuid,
 	uuidConstraintKind: () => uuidConstraintKind
 });
 //#endregion
-export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, ConstraintBase, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberInStringConstraint, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsJson, codecsKind, codecsString, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberInString, numberInStringConstraintKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind };
+export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, ConstraintBase, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberInStringConstraint, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsJson, codecsKind, codecsString, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isNullable, isOptional, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberInString, numberInStringConstraintKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, unwrapLazy, url, urlConstraintKind, uuid, uuidConstraintKind };

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

@@ -14,7 +14,7 @@ export interface StructureDefinition<GenericConstraints extends readonly Constra
     readonly message?: string;
     readonly constraints: readonly [...GenericConstraints];
 }
-export interface Structure<GenericValue extends unknown = unknown, GenericDefinition extends StructureDefinition<readonly Constraint<GenericValue>[]> = StructureDefinition<readonly Constraint<GenericValue>[]>> extends DKind.Kind<typeof structureKind, (GenericValue & StructureConstraintsValue<GenericDefinition["constraints"][number]>)> {
+export interface Structure<out GenericValue extends unknown = unknown, out GenericDefinition extends StructureDefinition<readonly Constraint<GenericValue>[]> = StructureDefinition<readonly Constraint<GenericValue>[]>> extends DKind.Kind<typeof structureKind, (GenericValue & StructureConstraintsValue<GenericDefinition["constraints"][number]>)> {
     readonly definition: GenericDefinition;
     addConstraint<const GenericNewConstraints extends DCommon.AnyTuple<Constraint<GenericValue>>>(...args: DCommon.FixDeepFunctionInfer<DCommon.AnyTuple<Constraint<GenericValue>>, GenericNewConstraints>): Structure<StructureValue<this>, StructureDefinition<readonly [...this["definition"]["constraints"], ...GenericNewConstraints]>>;
     executeConstraints(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;

package/dist/dataStructure/structure/defaults/array.d.ts

@@ -13,6 +13,6 @@ export declare const arrayStructureKind: DKind.Handler<DKind.Definition<"@Duploj
 export interface ArrayStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly element: Structure;
 }
-export interface ArrayStructure<GenericValue extends readonly unknown[] = readonly unknown[], GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ArrayStructureDefinition<GenericConstraints>> & DKind.Kind<typeof arrayStructureKind>> {
+export interface ArrayStructure<out GenericValue extends readonly unknown[] = readonly unknown[], out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ArrayStructureDefinition<GenericConstraints>> & DKind.Kind<typeof arrayStructureKind>> {
 }
 export declare const ArrayStructure: <GenericElement extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericElement>[]>[]>(element: GenericElement, constraints: GenericConstraints) => NoInfer<ArrayStructure<readonly StructureValue<GenericElement>[], readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/lazy.d.ts

@@ -7,6 +7,6 @@ export declare const lazyStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface LazyStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly getter: DCommon.Memoized<Structure>;
 }
-export interface LazyStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
+export interface LazyStructure<out GenericValue extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
 }
 export declare const LazyStructure: <GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[]>(getStructure: () => GenericStructure, constraints: GenericConstraints) => NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/object.d.ts

@@ -25,6 +25,6 @@ export interface ObjectStructureDefinition<GenericConstraints extends readonly C
     readonly shape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
     readonly keys: readonly string[];
 }
-export interface ObjectStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {
+export interface ObjectStructure<out GenericValue extends Record<string, unknown> = Record<string, unknown>, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {
 }
 export declare const ObjectStructure: <GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[]>(shape: GenericShape, constraints: GenericConstraints) => NoInfer<ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/record.d.ts

@@ -14,6 +14,6 @@ export interface RecordStructureDefinition<GenericConstraints extends readonly C
     readonly value: Structure;
     readonly requiredKeys: DCommon.Memoized<string[] | null>;
 }
-export interface RecordStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, RecordStructureDefinition<GenericConstraints>> & DKind.Kind<typeof recordStructureKind>> {
+export interface RecordStructure<out GenericValue extends Record<string, unknown> = Record<string, unknown>, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, RecordStructureDefinition<GenericConstraints>> & DKind.Kind<typeof recordStructureKind>> {
 }
 export declare const RecordStructure: <GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[]>(key: GenericKey, value: GenericValueStructure, constraints: GenericConstraints) => NoInfer<RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>>;