@bemedev/typings 0.2.2 → 0.4.0

package/lib/helpers/primitive.js

@@ -1,25 +1,25 @@
-import { expandFn } from "../utils/expandFn.js";
+import { standardize2 } from "../standard.js";
+import { expandFn2 } from "../utils/expandFn.js";
+import { _const } from "../utils/index.js";
 //#region src/helpers/primitive.ts
-const primitive = expandFn((value) => value, {
-	boolean: (value) => {
-		return value;
-	},
-	string: (value) => {
-		return value;
-	},
-	number: (value) => {
-		return value;
-	},
-	bigint: (value) => {
-		return value;
-	},
-	symbol: (value) => {
-		return value;
-	},
-	never: () => {},
-	undefined: () => {}
+const primitive = expandFn2((value) => standardize2(value), _const(), {
+	boolean: expandFn2((value) => {
+		return standardize2(value);
+	}, "boolean"),
+	string: expandFn2((value) => {
+		return standardize2(value);
+	}, "string"),
+	number: expandFn2((value) => {
+		return standardize2(value);
+	}, "number"),
+	bigint: expandFn2((value) => {
+		return standardize2(value);
+	}, "bigint"),
+	symbol: expandFn2((value) => {
+		return standardize2(value);
+	}, "symbol"),
+	never: standardize2(),
+	undefined: standardize2()
 });
 //#endregion
 export { primitive };
-
-//# sourceMappingURL=primitive.js.map

package/lib/helpers/primitiveObject.cjs

@@ -1,11 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_standard = require("../standard.cjs");
+const require_utils_expandFn = require("../utils/expandFn.cjs");
+const require_utils_index = require("../utils/index.cjs");
 //#region src/helpers/primitiveObject.ts
-const primitiveObject = require("../utils/expandFn.cjs").expandFn((value) => {
-	return value || {};
-}, { map: (value) => {
-	return value || {};
-} });
+const primitiveObject = require_utils_expandFn.expandFn2((value) => {
+	return require_standard.standardize2(value);
+}, require_utils_index._const(), { map: require_utils_expandFn.expandFn2((value) => {
+	return require_standard.standardize2(value);
+}, require_utils_index._const()) });
 //#endregion
 exports.primitiveObject = primitiveObject;
-
-//# sourceMappingURL=primitiveObject.cjs.map

package/lib/helpers/primitiveObject.d.ts

@@ -1,5 +1,10 @@
 import type { IntersectionCustom, NotReadonly, PrimitiveObjectMapS, PrimitiveObjectT } from "../types";
-declare const primitiveObject: import("..").FnBasic<(<const T extends PrimitiveObjectT | IntersectionCustom<PrimitiveObjectMapS[]> = PrimitiveObjectT>(value?: T) => NotReadonly<T>), {
-    readonly map: <const T extends PrimitiveObjectMapS | IntersectionCustom<PrimitiveObjectMapS[]> = PrimitiveObjectMapS>(value?: T) => NotReadonly<T>;
+export declare const primitiveObject: import("..").FnBasic<(<const T extends PrimitiveObjectT | IntersectionCustom<PrimitiveObjectMapS[]> = PrimitiveObjectT>(value?: T) => NotReadonly<T>), {
+    readonly map: import("..").FnBasic<(<const T extends PrimitiveObjectMapS | IntersectionCustom<PrimitiveObjectMapS[]> = PrimitiveObjectMapS>(value?: T) => NotReadonly<T>), object & {
+        const: PrimitiveObjectMapS;
+        type: PrimitiveObjectMapS;
+    }>;
+} & {
+    const: PrimitiveObjectT;
+    type: PrimitiveObjectT;
 }>;
-export { primitiveObject };

package/lib/helpers/primitiveObject.js

@@ -1,11 +1,11 @@
-import { expandFn } from "../utils/expandFn.js";
+import { standardize2 } from "../standard.js";
+import { expandFn2 } from "../utils/expandFn.js";
+import { _const } from "../utils/index.js";
 //#region src/helpers/primitiveObject.ts
-const primitiveObject = expandFn((value) => {
-	return value || {};
-}, { map: (value) => {
-	return value || {};
-} });
+const primitiveObject = expandFn2((value) => {
+	return standardize2(value);
+}, _const(), { map: expandFn2((value) => {
+	return standardize2(value);
+}, _const()) });
 //#endregion
 export { primitiveObject };
-
-//# sourceMappingURL=primitiveObject.js.map

package/lib/helpers/readonly.cjs

@@ -3,5 +3,3 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const readonly = (value) => value;
 //#endregion
 exports.readonly = readonly;
-
-//# sourceMappingURL=readonly.cjs.map

package/lib/helpers/readonly.js

@@ -2,5 +2,3 @@
 const readonly = (value) => value;
 //#endregion
 export { readonly };
-
-//# sourceMappingURL=readonly.js.map

package/lib/helpers/record.cjs

@@ -1,12 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_standard = require("../standard.cjs");
+const require_utils_expandFn = require("../utils/expandFn.cjs");
+const require_helpers_object = require("./object.cjs");
 //#region src/helpers/record.ts
-const record = (value, ...keys) => {
-	return keys.reduce((acc, key) => {
+const record = require_utils_expandFn.expandFn2((value, ...keys) => {
+	return require_standard.standardize2(keys.reduce((acc, key) => {
 		acc[key] = value;
 		return acc;
-	}, {});
-};
+	}, {}));
+}, require_helpers_object.object.const);
 //#endregion
 exports.record = record;
-
-//# sourceMappingURL=record.cjs.map

package/lib/helpers/record.d.ts

@@ -1,3 +1,5 @@
 import type { Keys, ObjectT } from "../types";
-declare const record: <const K extends Keys[], V extends ObjectT>(value: V, ...keys: K) => Record<K[number] extends never ? Keys : K[number], V>;
-export { record };
+export declare const record: import("..").FnBasic<(<const K extends Keys[], V extends ObjectT>(value: V, ...keys: K) => Record<K[number] extends never ? string | number | symbol : K[number], V>), object & {
+    const: import("..").ObjectMapS;
+    type: import("..").ObjectMapS;
+}>;

package/lib/helpers/record.js

@@ -1,11 +1,12 @@
+import { standardize2 } from "../standard.js";
+import { expandFn2 } from "../utils/expandFn.js";
+import { object } from "./object.js";
 //#region src/helpers/record.ts
-const record = (value, ...keys) => {
-	return keys.reduce((acc, key) => {
+const record = expandFn2((value, ...keys) => {
+	return standardize2(keys.reduce((acc, key) => {
 		acc[key] = value;
 		return acc;
-	}, {});
-};
+	}, {}));
+}, object.const);
 //#endregion
 export { record };
-
-//# sourceMappingURL=record.js.map

package/lib/helpers/soa.cjs

@@ -1,10 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_constants = require("../constants.cjs");
+const require_standard = require("../standard.cjs");
 //#region src/helpers/soa.ts
 const soa = (value) => {
-	return { [require_constants.SOA]: value };
+	return require_standard.standardize2(value);
 };
 //#endregion
 exports.soa = soa;
-
-//# sourceMappingURL=soa.cjs.map

package/lib/helpers/soa.d.ts

@@ -1,3 +1,2 @@
 import type { NotReadonly, ObjectT, SoaCustom } from "../types";
-declare const soa: <const T extends ObjectT>(value: T) => SoaCustom<NotReadonly<T>>;
-export { soa };
+export declare const soa: <const T extends ObjectT>(value?: T) => ObjectT extends NotReadonly<T> ? "any" : SoaCustom<NotReadonly<T>>;

package/lib/helpers/soa.js

@@ -1,9 +1,7 @@
-import { SOA } from "../constants.js";
+import { standardize2 } from "../standard.js";
 //#region src/helpers/soa.ts
 const soa = (value) => {
-	return { [SOA]: value };
+	return standardize2(value);
 };
 //#endregion
 export { soa };
-
-//# sourceMappingURL=soa.js.map

package/lib/helpers/sv.cjs

@@ -1,7 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_standard = require("../standard.cjs");
+const require_utils_expandFn = require("../utils/expandFn.cjs");
+const require_utils_index = require("../utils/index.cjs");
 //#region src/helpers/sv.ts
-const sv = {};
+const sv = require_utils_expandFn.expandFn2((value) => {
+	return require_standard.standardize2(value);
+}, require_utils_index._const());
 //#endregion
 exports.sv = sv;
-
-//# sourceMappingURL=sv.cjs.map

package/lib/helpers/sv.d.ts

@@ -1,3 +1,5 @@
 import type { Custom, StateValue } from "../types";
-declare const sv: Custom<StateValue>;
-export { sv };
+export declare const sv: import("..").FnBasic<(<const T extends StateValue = StateValue>(value?: T) => StateValue extends T ? Custom<StateValue> : Custom<T>), object & {
+    const: Custom<StateValue>;
+    type: Custom<StateValue>;
+}>;

package/lib/helpers/sv.js

@@ -1,6 +1,9 @@
+import { standardize2 } from "../standard.js";
+import { expandFn2 } from "../utils/expandFn.js";
+import { _const } from "../utils/index.js";
 //#region src/helpers/sv.ts
-const sv = {};
+const sv = expandFn2((value) => {
+	return standardize2(value);
+}, _const());
 //#endregion
 export { sv };
-
-//# sourceMappingURL=sv.js.map

package/lib/helpers/tuple.cjs

@@ -1,7 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_standard = require("../standard.cjs");
+const require_utils_expandFn = require("../utils/expandFn.cjs");
+const require_helpers_array = require("./array.cjs");
 //#region src/helpers/tuple.ts
-const tuple = (...values) => values;
+const tuple = require_utils_expandFn.expandFn2((...values) => {
+	return require_standard.standardize2(values);
+}, require_helpers_array.array.type);
 //#endregion
 exports.tuple = tuple;
-
-//# sourceMappingURL=tuple.cjs.map

package/lib/helpers/tuple.d.ts

@@ -1,3 +1,5 @@
 import type { NotReadonly, ObjectT } from "../types";
-declare const tuple: <const T extends [ObjectT, ...ObjectT[]]>(...values: T) => NotReadonly<T>;
-export { tuple };
+export declare const tuple: import("..").FnBasic<(<const T extends [ObjectT, ...ObjectT[]]>(...values: T) => NotReadonly<T>), object & {
+    const: import("..").ArrayCustom;
+    type: import("..").ArrayCustom;
+}>;

package/lib/helpers/tuple.js

@@ -1,6 +1,9 @@
+import { standardize2 } from "../standard.js";
+import { expandFn2 } from "../utils/expandFn.js";
+import { array } from "./array.js";
 //#region src/helpers/tuple.ts
-const tuple = (...values) => values;
+const tuple = expandFn2((...values) => {
+	return standardize2(values);
+}, array.type);
 //#endregion
 export { tuple };
-
-//# sourceMappingURL=tuple.js.map

package/lib/helpers/union.cjs

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_standard = require("../standard.cjs");
 const require_utils_expandFn = require("../utils/expandFn.cjs");
+const require_constants = require("../constants.cjs");
 //#region src/helpers/union.ts
 const _union = (...values) => {
-	return values[0];
+	return require_standard.standardize2({ [require_constants.UNION]: values });
 };
 const union = require_utils_expandFn.expandFn(_union, { discriminated: (_key, ...values) => _union(...values) });
 //#endregion
 exports.union = union;
-
-//# sourceMappingURL=union.cjs.map

package/lib/helpers/union.d.ts

@@ -1,6 +1,6 @@
 import type { Keys, ObjectMapS, ObjectT } from "../types";
 type Discriminated<K extends Keys> = ObjectMapS & Record<K, ObjectT>;
-declare const union: import("..").FnBasic<(<T extends [ObjectT, ObjectT, ...ObjectT[]]>(...values: T) => T[number]), {
+export declare const union: import("..").FnBasic<(<T extends [ObjectT, ObjectT, ...ObjectT[]]>(...values: T) => T[number]), {
     readonly discriminated: <const K extends Keys, T extends [Discriminated<K>, Discriminated<K>, ...Discriminated<K>[]]>(_key: K, ...values: T) => T[number];
 }>;
-export { union };
+export {};

package/lib/helpers/union.js

@@ -1,10 +1,10 @@
+import { standardize2 } from "../standard.js";
 import { expandFn } from "../utils/expandFn.js";
+import { UNION } from "../constants.js";
 //#region src/helpers/union.ts
 const _union = (...values) => {
-	return values[0];
+	return standardize2({ [UNION]: values });
 };
 const union = expandFn(_union, { discriminated: (_key, ...values) => _union(...values) });
 //#endregion
 export { union };
-
-//# sourceMappingURL=union.js.map

package/lib/index.cjs

@@ -1,20 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_types = require("./types.cjs");
 const require_constants = require("./constants.cjs");
-const require_helpers_index = require("./helpers/index.cjs");
 const require_type = require("./type.cjs");
 exports.ARRAY = require_constants.ARRAY;
 exports.CUSTOM = require_constants.CUSTOM;
+exports.LITTERALS = require_constants.LITTERALS;
 exports.OPTIONAL = require_constants.OPTIONAL;
-exports.OptionalHelperClass = require_types.OptionalHelperClass;
 exports.PARTIAL = require_constants.PARTIAL;
 exports.PRIMITIVES = require_constants.PRIMITIVES;
 exports.PRIMITIVE_OBJECTS = require_constants.PRIMITIVE_OBJECTS;
 exports.SOA = require_constants.SOA;
-Object.defineProperty(exports, "helpers", {
-	enumerable: true,
-	get: function() {
-		return require_helpers_index.helpers_exports;
-	}
-});
+exports.UNION = require_constants.UNION;
 exports.type = require_type.type;

package/lib/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./constants";
-export * as helpers from "./helpers";
 export * from "./type";
 export * from "./types";

package/lib/index.js

@@ -1,5 +1,3 @@
-import { OptionalHelperClass } from "./types.js";
-import { ARRAY, CUSTOM, OPTIONAL, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA } from "./constants.js";
-import { helpers_exports } from "./helpers/index.js";
+import { ARRAY, CUSTOM, LITTERALS, OPTIONAL, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA, UNION } from "./constants.js";
 import { type } from "./type.js";
-export { ARRAY, CUSTOM, OPTIONAL, OptionalHelperClass, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA, helpers_exports as helpers, type };
+export { ARRAY, CUSTOM, LITTERALS, OPTIONAL, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA, UNION, type };

package/lib/standard.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/standard.ts
+const _standardize = (value) => {
+	return {
+		value,
+		"~standard": {
+			version: 1,
+			vendor: "@bemedev/typings",
+			types: {
+				input: value,
+				output: value
+			},
+			validate: () => ({ value })
+		}
+	};
+};
+const standardize = _standardize;
+const standardize2 = (value) => value;
+//#endregion
+exports.standardize = standardize;
+exports.standardize2 = standardize2;

package/lib/standard.d.ts

@@ -0,0 +1,7 @@
+import type { StandardSchemaV1 } from "./standard.types";
+type Standardize_F = <T>(value: T) => {
+    value: T;
+} & StandardSchemaV1<T, T>;
+export declare const standardize: Standardize_F;
+export declare const standardize2: <T>(value?: unknown) => T;
+export {};

package/lib/standard.js

@@ -0,0 +1,19 @@
+//#region src/standard.ts
+const _standardize = (value) => {
+	return {
+		value,
+		"~standard": {
+			version: 1,
+			vendor: "@bemedev/typings",
+			types: {
+				input: value,
+				output: value
+			},
+			validate: () => ({ value })
+		}
+	};
+};
+const standardize = _standardize;
+const standardize2 = (value) => value;
+//#endregion
+export { standardize, standardize2 };

package/lib/standard.types.d.ts

@@ -0,0 +1,59 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: "@bemedev/typings";
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}

package/lib/type.cjs

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_standard = require("./standard.cjs");
+const require_helpers_any = require("./helpers/any.cjs");
+const require_helpers_array = require("./helpers/array.cjs");
+const require_helpers_custom = require("./helpers/custom.cjs");
+const require_helpers_intersection = require("./helpers/intersection.cjs");
+const require_helpers_union = require("./helpers/union.cjs");
+const require_helpers_litterals = require("./helpers/litterals.cjs");
+const require_helpers_optional = require("./helpers/optional.cjs");
+const require_helpers_partial = require("./helpers/partial.cjs");
+const require_helpers_primitive = require("./helpers/primitive.cjs");
+const require_helpers_primitiveObject = require("./helpers/primitiveObject.cjs");
+const require_helpers_readonly = require("./helpers/readonly.cjs");
+const require_helpers_object = require("./helpers/object.cjs");
+const require_helpers_record = require("./helpers/record.cjs");
+const require_helpers_soa = require("./helpers/soa.cjs");
+const require_helpers_sv = require("./helpers/sv.cjs");
+const require_helpers_tuple = require("./helpers/tuple.cjs");
+require("./helpers/index.cjs");
+//#region src/type.ts
+const _transform = (obj) => {
+	return obj;
+};
+const type = (option) => {
+	let out;
+	if (!option) out = option;
+	else if (typeof option === "function") out = _transform(option({
+		any: require_helpers_any.any,
+		custom: require_helpers_custom.custom,
+		intersection: require_helpers_intersection.intersection,
+		litterals: require_helpers_litterals.litterals,
+		optional: require_helpers_optional.optional,
+		partial: require_helpers_partial.partial,
+		record: require_helpers_record.record,
+		soa: require_helpers_soa.soa,
+		sv: require_helpers_sv.sv,
+		union: require_helpers_union.union,
+		array: require_helpers_array.array,
+		tuple: require_helpers_tuple.tuple,
+		primitiveObject: require_helpers_primitiveObject.primitiveObject,
+		primitive: require_helpers_primitive.primitive,
+		readonly: require_helpers_readonly.readonly,
+		object: require_helpers_object.object
+	}));
+	else out = _transform(option);
+	return require_standard.standardize(out);
+};
+//#endregion
+exports.type = type;

package/lib/type.js

@@ -0,0 +1,48 @@
+import { standardize } from "./standard.js";
+import { any } from "./helpers/any.js";
+import { array } from "./helpers/array.js";
+import { custom } from "./helpers/custom.js";
+import { intersection } from "./helpers/intersection.js";
+import { union } from "./helpers/union.js";
+import { litterals } from "./helpers/litterals.js";
+import { optional } from "./helpers/optional.js";
+import { partial } from "./helpers/partial.js";
+import { primitive } from "./helpers/primitive.js";
+import { primitiveObject } from "./helpers/primitiveObject.js";
+import { readonly } from "./helpers/readonly.js";
+import { object } from "./helpers/object.js";
+import { record } from "./helpers/record.js";
+import { soa } from "./helpers/soa.js";
+import { sv } from "./helpers/sv.js";
+import { tuple } from "./helpers/tuple.js";
+import "./helpers/index.js";
+//#region src/type.ts
+const _transform = (obj) => {
+	return obj;
+};
+const type = (option) => {
+	let out;
+	if (!option) out = option;
+	else if (typeof option === "function") out = _transform(option({
+		any,
+		custom,
+		intersection,
+		litterals,
+		optional,
+		partial,
+		record,
+		soa,
+		sv,
+		union,
+		array,
+		tuple,
+		primitiveObject,
+		primitive,
+		readonly,
+		object
+	}));
+	else out = _transform(option);
+	return standardize(out);
+};
+//#endregion
+export { type };

package/lib/type.types.d.ts

@@ -1,5 +1,5 @@
-import type { inferT, ObjectT } from "./types";
-import type { any, array, custom, intersection, litterals, optional, partial, primitive, primitiveObject, readonly, record, soa, sv, tuple, union } from "./helpers";
+import type { any, array, custom, intersection, litterals, optional, partial, primitive, primitiveObject, readonly, record, soa, sv, tuple, union, object } from "./helpers";
+import type { ObjectT, inferT } from "./types";
 export type Helpers = {
     any: typeof any;
     custom: typeof custom;
@@ -16,5 +16,6 @@ export type Helpers = {
     primitiveObject: typeof primitiveObject;
     primitive: typeof primitive;
     readonly: typeof readonly;
+    object: typeof object;
 };
 export type Transform_F = <T extends ObjectT = ObjectT>(option?: ((helpers: Helpers) => T) | T) => inferT<T>;

package/lib/types.d.ts

@@ -1,4 +1,5 @@
 import type { ARRAY, CUSTOM, OPTIONAL, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA } from "./constants";
+import type { StandardSchemaV1 } from "./standard.types";
 export type Ru = Record<Keys, unknown>;
 export type TrueObject = Ru & {
     [Symbol.iterator]?: never;
@@ -24,9 +25,9 @@ type RecursiveArrayOf<T> = Array<_SingleOrRecursiveArrayOf<T>> | ReadonlyArray<_
 type _SingleOrRecursiveArrayOf<T> = T | RecursiveArrayOf<T>;
 export type SingleOrRecursiveArrayOf<T> = T | RecursiveArrayOf<T>;
 export type SoRa<T> = SingleOrRecursiveArrayOf<T>;
-export type Primiive = string | number | boolean | bigint | null | undefined | symbol | never;
+export type Primitive = string | number | boolean | bigint | null | undefined | symbol | never;
 export type PrimitiveT = (typeof PRIMITIVES)[number];
-type TransformPrimitiveS<T extends PrimitiveT> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "bigint" ? bigint : T extends "null" ? null : T extends "undefined" ? undefined : T extends "symbol" ? symbol : T extends "never" ? never : Primiive;
+type TransformPrimitiveS<T extends PrimitiveT> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "bigint" ? bigint : T extends "null" ? null : T extends "undefined" ? undefined : T extends "symbol" ? symbol : T extends "never" ? never : Primitive;
 export type Types = PrimitiveT | (typeof PRIMITIVE_OBJECTS)[number];
 export type TransformTypes<T extends Types> = T extends PrimitiveT ? TransformPrimitiveS<T> : T extends "date" ? Date : T extends "any" ? any : T extends "unknown" ? unknown : object;
 export type Custom<T = any> = {
@@ -38,7 +39,8 @@ export type SoaCustom<T extends ObjectT = any> = {
 export type PartialCustom = {
     [PARTIAL]: undefined;
 };
-export type __ObjectT = Types | ObjectMapS | Custom | PartialCustom;
+export type __ObjectT = Types | ObjectMapS | Custom | PartialCustom | PrimitiveObjectT;
+export type CanOptional = __ObjectT | ArrayCustom | AnyArray<__ObjectT>;
 export type Optional<T extends __ObjectT | ArrayCustom | AnyArray<__ObjectT> = __ObjectT> = {
     [OPTIONAL]: T;
 };
@@ -48,7 +50,7 @@ export type ArrayCustom<T extends ObjectT = any> = {
 export type ObjectMapS = {
     [key: Keys]: SoRa<_ObjectT>;
 };
-export declare class OptionalHelperClass {
+declare class OptionalHelperClass {
     readonly __NO_TYPE__ = "@bemedev/addons/NO_TYPE";
     private constructor();
 }
@@ -66,7 +68,7 @@ export interface PrimitiveObjectMapS {
  *
  * @remark
  */
-export type ObjectT = SoRa<_ObjectT | PrimitiveObjectT>;
+export type ObjectT = SoRa<_ObjectT>;
 export type POS = ObjectT;
 type ReduceTuple2<T extends AnyArray<ObjectT>> = T extends [
     infer First,
@@ -89,6 +91,11 @@ type UndefinyObject<T extends object> = {
 } : never;
 type Undefiny<T, U = Exclude<T, OptionalHelperClass>> = U extends AnyArray ? ReduceTupleU<U> : U extends Ru ? UndefinyObject<U> : U;
 type TransformT<T> = Undefiny<__TransformPrimitiveObject<T>>;
-export type inferT<T extends ObjectT = ObjectT> = ObjectT extends T ? unknown : TransformT<T>;
+export type StandardHelper<T = any> = {
+    value: T;
+} & StandardSchemaV1<T, T>;
+export type Sh<T = any> = StandardHelper<T>;
+export type inferT<T extends ObjectT = ObjectT> = ObjectT extends T ? Sh<unknown> : Sh<TransformT<T>>;
+export type infer<T extends Sh> = T["value"];
 export type FnBasic<Main extends Fn, Tr extends object> = Tr & Main;
 export {};