@nxtedition/types 23.0.40 → 23.0.42

package/dist/common/rule.d.ts

@@ -1,5 +1,4 @@
-import { type AssertionGuard as __AssertionGuard } from "typia";
-import { tags } from 'typia';
+import type { tags } from 'typia';
 export interface Rule {
     locations: string[];
     replicas: number & tags.Type<"uint32">;
@@ -7,9 +6,4 @@ export interface Rule {
     includes: string[];
     excludes: string[];
 }
-export declare const isRule: (input: unknown) => input is Rule;
 export declare const assertRule: (input: unknown) => Rule;
-export declare const randomRule: () => Rule;
-export declare const assertGuardRule: __AssertionGuard<Rule>;
-export declare const stringifyRule: (input: Rule) => string;
-export declare const assertStringifyRule: (input: unknown) => string;

package/dist/common/rule.js

@@ -1,255 +1,85 @@
-import __typia from "typia";
-export const isRule = input => {
-    const $io0 = input => Array.isArray(input.locations) && input.locations.every(elem => "string" === typeof elem) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295)) && (Array.isArray(input.includes) && input.includes.every(elem => "string" === typeof elem)) && (Array.isArray(input.excludes) && input.excludes.every(elem => "string" === typeof elem));
-    return "object" === typeof input && null !== input && $io0(input);
-};
-export const assertRule = (input, errorFactory) => {
-    const __is = input => {
-        const $io0 = input => Array.isArray(input.locations) && input.locations.every(elem => "string" === typeof elem) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295)) && (Array.isArray(input.includes) && input.includes.every(elem => "string" === typeof elem)) && (Array.isArray(input.excludes) && input.excludes.every(elem => "string" === typeof elem));
-        return "object" === typeof input && null !== input && $io0(input);
-    };
-    if (false === __is(input))
-        ((input, _path, _exceptionable = true) => {
-            const $guard = __typia.createAssert.guard;
-            const $ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.locations) || $guard(_exceptionable, {
-                path: _path + ".locations",
-                expected: "Array<string>",
-                value: input.locations
-            }, errorFactory)) && input.locations.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".locations[" + _index1 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".locations",
-                expected: "Array<string>",
-                value: input.locations
-            }, errorFactory)) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295 || $guard(_exceptionable, {
-                path: _path + ".replicas",
-                expected: "number & Type<\"uint32\">",
-                value: input.replicas
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".replicas",
-                expected: "(number & Type<\"uint32\">)",
-                value: input.replicas
-            }, errorFactory)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295 || $guard(_exceptionable, {
-                path: _path + ".priority",
-                expected: "number & Type<\"uint32\">",
-                value: input.priority
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".priority",
-                expected: "(number & Type<\"uint32\">)",
-                value: input.priority
-            }, errorFactory)) && ((Array.isArray(input.includes) || $guard(_exceptionable, {
-                path: _path + ".includes",
-                expected: "Array<string>",
-                value: input.includes
-            }, errorFactory)) && input.includes.every((elem, _index2) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".includes[" + _index2 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".includes",
-                expected: "Array<string>",
-                value: input.includes
-            }, errorFactory)) && ((Array.isArray(input.excludes) || $guard(_exceptionable, {
-                path: _path + ".excludes",
-                expected: "Array<string>",
-                value: input.excludes
-            }, errorFactory)) && input.excludes.every((elem, _index3) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".excludes[" + _index3 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".excludes",
-                expected: "Array<string>",
-                value: input.excludes
-            }, errorFactory));
-            return ("object" === typeof input && null !== input || $guard(true, {
-                path: _path + "",
-                expected: "Rule",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "Rule",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
+import * as __typia_transform__isTypeUint32 from "typia/lib/internal/_isTypeUint32.js";
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import typia from 'typia';
+export const assertRule = (() => { const _io0 = input => Array.isArray(input.locations) && input.locations.every(elem => "string" === typeof elem) && ("number" === typeof input.replicas && __typia_transform__isTypeUint32._isTypeUint32(input.replicas)) && ("number" === typeof input.priority && __typia_transform__isTypeUint32._isTypeUint32(input.priority)) && (Array.isArray(input.includes) && input.includes.every(elem => "string" === typeof elem)) && (Array.isArray(input.excludes) && input.excludes.every(elem => "string" === typeof elem)); const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.locations) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".locations",
+    expected: "Array<string>",
+    value: input.locations
+}, _errorFactory)) && input.locations.every((elem, _index4) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".locations[" + _index4 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".locations",
+    expected: "Array<string>",
+    value: input.locations
+}, _errorFactory)) && ("number" === typeof input.replicas && (__typia_transform__isTypeUint32._isTypeUint32(input.replicas) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".replicas",
+    expected: "number & Type<\"uint32\">",
+    value: input.replicas
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".replicas",
+    expected: "(number & Type<\"uint32\">)",
+    value: input.replicas
+}, _errorFactory)) && ("number" === typeof input.priority && (__typia_transform__isTypeUint32._isTypeUint32(input.priority) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".priority",
+    expected: "number & Type<\"uint32\">",
+    value: input.priority
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".priority",
+    expected: "(number & Type<\"uint32\">)",
+    value: input.priority
+}, _errorFactory)) && ((Array.isArray(input.includes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".includes",
+    expected: "Array<string>",
+    value: input.includes
+}, _errorFactory)) && input.includes.every((elem, _index5) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".includes[" + _index5 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".includes",
+    expected: "Array<string>",
+    value: input.includes
+}, _errorFactory)) && ((Array.isArray(input.excludes) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".excludes",
+    expected: "Array<string>",
+    value: input.excludes
+}, _errorFactory)) && input.excludes.every((elem, _index6) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".excludes[" + _index6 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".excludes",
+    expected: "Array<string>",
+    value: input.excludes
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "typia.createAssert",
+            path: _path + "",
+            expected: "Rule",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "typia.createAssert",
+            path: _path + "",
+            expected: "Rule",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
     return input;
-};
-export const randomRule = generator => {
-    const $generator = __typia.createRandom.generator;
-    const $ro0 = (_recursive = false, _depth = 0) => ({
-        locations: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()),
-        replicas: (generator?.customs ?? $generator.customs)?.number?.([
-            {
-                name: "Type<\"uint32\">",
-                kind: "type",
-                value: "uint32"
-            }
-        ]) ?? (generator?.integer ?? $generator.integer)(0, 10),
-        priority: (generator?.customs ?? $generator.customs)?.number?.([
-            {
-                name: "Type<\"uint32\">",
-                kind: "type",
-                value: "uint32"
-            }
-        ]) ?? (generator?.integer ?? $generator.integer)(0, 10),
-        includes: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()),
-        excludes: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
-    });
-    return $ro0();
-};
-export const assertGuardRule = (input, errorFactory) => {
-    const __is = input => {
-        const $io0 = input => Array.isArray(input.locations) && input.locations.every(elem => "string" === typeof elem) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295)) && (Array.isArray(input.includes) && input.includes.every(elem => "string" === typeof elem)) && (Array.isArray(input.excludes) && input.excludes.every(elem => "string" === typeof elem));
-        return "object" === typeof input && null !== input && $io0(input);
-    };
-    if (false === __is(input))
-        ((input, _path, _exceptionable = true) => {
-            const $guard = __typia.createAssertGuard.guard;
-            const $ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.locations) || $guard(_exceptionable, {
-                path: _path + ".locations",
-                expected: "Array<string>",
-                value: input.locations
-            }, errorFactory)) && input.locations.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".locations[" + _index1 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".locations",
-                expected: "Array<string>",
-                value: input.locations
-            }, errorFactory)) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295 || $guard(_exceptionable, {
-                path: _path + ".replicas",
-                expected: "number & Type<\"uint32\">",
-                value: input.replicas
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".replicas",
-                expected: "(number & Type<\"uint32\">)",
-                value: input.replicas
-            }, errorFactory)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295 || $guard(_exceptionable, {
-                path: _path + ".priority",
-                expected: "number & Type<\"uint32\">",
-                value: input.priority
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".priority",
-                expected: "(number & Type<\"uint32\">)",
-                value: input.priority
-            }, errorFactory)) && ((Array.isArray(input.includes) || $guard(_exceptionable, {
-                path: _path + ".includes",
-                expected: "Array<string>",
-                value: input.includes
-            }, errorFactory)) && input.includes.every((elem, _index2) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".includes[" + _index2 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".includes",
-                expected: "Array<string>",
-                value: input.includes
-            }, errorFactory)) && ((Array.isArray(input.excludes) || $guard(_exceptionable, {
-                path: _path + ".excludes",
-                expected: "Array<string>",
-                value: input.excludes
-            }, errorFactory)) && input.excludes.every((elem, _index3) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".excludes[" + _index3 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".excludes",
-                expected: "Array<string>",
-                value: input.excludes
-            }, errorFactory));
-            return ("object" === typeof input && null !== input || $guard(true, {
-                path: _path + "",
-                expected: "Rule",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "Rule",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-};
-export const stringifyRule = input => {
-    const $string = __typia.json.createStringify.string;
-    const $so0 = input => `{"locations":${`[${input.locations.map(elem => $string(elem)).join(",")}]`},"replicas":${input.replicas},"priority":${input.priority},"includes":${`[${input.includes.map(elem => $string(elem)).join(",")}]`},"excludes":${`[${input.excludes.map(elem => $string(elem)).join(",")}]`}}`;
-    return $so0(input);
-};
-export const assertStringifyRule = (input, errorFactory) => { const assert = (input, errorFactory) => {
-    const __is = input => {
-        const $io0 = input => Array.isArray(input.locations) && input.locations.every(elem => "string" === typeof elem) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295)) && (Array.isArray(input.includes) && input.includes.every(elem => "string" === typeof elem)) && (Array.isArray(input.excludes) && input.excludes.every(elem => "string" === typeof elem));
-        return "object" === typeof input && null !== input && $io0(input);
-    };
-    if (false === __is(input))
-        ((input, _path, _exceptionable = true) => {
-            const $guard = __typia.json.createAssertStringify.guard;
-            const $ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.locations) || $guard(_exceptionable, {
-                path: _path + ".locations",
-                expected: "Array<string>",
-                value: input.locations
-            }, errorFactory)) && input.locations.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".locations[" + _index1 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".locations",
-                expected: "Array<string>",
-                value: input.locations
-            }, errorFactory)) && ("number" === typeof input.replicas && (Math.floor(input.replicas) === input.replicas && 0 <= input.replicas && input.replicas <= 4294967295 || $guard(_exceptionable, {
-                path: _path + ".replicas",
-                expected: "number & Type<\"uint32\">",
-                value: input.replicas
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".replicas",
-                expected: "(number & Type<\"uint32\">)",
-                value: input.replicas
-            }, errorFactory)) && ("number" === typeof input.priority && (Math.floor(input.priority) === input.priority && 0 <= input.priority && input.priority <= 4294967295 || $guard(_exceptionable, {
-                path: _path + ".priority",
-                expected: "number & Type<\"uint32\">",
-                value: input.priority
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".priority",
-                expected: "(number & Type<\"uint32\">)",
-                value: input.priority
-            }, errorFactory)) && ((Array.isArray(input.includes) || $guard(_exceptionable, {
-                path: _path + ".includes",
-                expected: "Array<string>",
-                value: input.includes
-            }, errorFactory)) && input.includes.every((elem, _index2) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".includes[" + _index2 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".includes",
-                expected: "Array<string>",
-                value: input.includes
-            }, errorFactory)) && ((Array.isArray(input.excludes) || $guard(_exceptionable, {
-                path: _path + ".excludes",
-                expected: "Array<string>",
-                value: input.excludes
-            }, errorFactory)) && input.excludes.every((elem, _index3) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".excludes[" + _index3 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".excludes",
-                expected: "Array<string>",
-                value: input.excludes
-            }, errorFactory));
-            return ("object" === typeof input && null !== input || $guard(true, {
-                path: _path + "",
-                expected: "Rule",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "Rule",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-    return input;
-}; const stringify = input => {
-    const $string = __typia.json.createAssertStringify.string;
-    const $so0 = input => `{"locations":${`[${input.locations.map(elem => $string(elem)).join(",")}]`},"replicas":${input.replicas},"priority":${input.priority},"includes":${`[${input.includes.map(elem => $string(elem)).join(",")}]`},"excludes":${`[${input.excludes.map(elem => $string(elem)).join(",")}]`}}`;
-    return $so0(input);
-}; return stringify(assert(input, errorFactory)); };
+}; })();

package/dist/common/search.d.ts

@@ -1,13 +1,6 @@
-import { type AssertionGuard as __AssertionGuard } from "typia";
 export type Search<Type extends "simple" | "conditional" = "simple"> = {
     type: Type;
 } & Type extends "simple" ? SimpleSearch : ConditionalSearch;
-export declare const isSearch: (input: unknown) => input is SimpleSearch;
-export declare const assertSearch: (input: unknown) => SimpleSearch;
-export declare const randomSearch: () => SimpleSearch;
-export declare const assertGuardSearch: __AssertionGuard<Search>;
-export declare const stringifySearch: (input: SimpleSearch) => string;
-export declare const assertStringifySearch: (input: unknown) => string;
 export interface SimpleSearch {
     type: "simple";
     user?: string;
@@ -20,12 +13,6 @@ export interface SimpleSearch {
     refreshInterval?: number;
     highlight?: SearchHighlightOption;
 }
-export declare const isSimpleSearch: (input: unknown) => input is SimpleSearch;
-export declare const assertSimpleSearch: (input: unknown) => SimpleSearch;
-export declare const randomSimpleSearch: () => SimpleSearch;
-export declare const assertGuardSimpleSearch: __AssertionGuard<SimpleSearch>;
-export declare const stringifySimpleSearch: (input: SimpleSearch) => string;
-export declare const assertStringifySimpleSearch: (input: unknown) => string;
 export interface ConditionalSearch {
     type: "conditional";
     user?: string;
@@ -50,20 +37,8 @@ export interface ConditionalSearch {
         y2: number;
     };
 }
-export declare const isConditionalSearch: (input: unknown) => input is ConditionalSearch;
-export declare const assertConditionalSearch: (input: unknown) => ConditionalSearch;
-export declare const randomConditionalSearch: () => ConditionalSearch;
-export declare const assertGuardConditionalSearch: __AssertionGuard<ConditionalSearch>;
-export declare const stringifyConditionalSearch: (input: ConditionalSearch) => string;
-export declare const assertStringifyConditionalSearch: (input: unknown) => string;
 export interface SearchHighlightOption {
     fields: {
         [field: string]: unknown;
     };
 }
-export declare const isSearchHighlightOption: (input: unknown) => input is SearchHighlightOption;
-export declare const assertSearchHighlightOption: (input: unknown) => SearchHighlightOption;
-export declare const randomSearchHighlightOption: () => SearchHighlightOption;
-export declare const assertGuardSearchHighlightOption: __AssertionGuard<SearchHighlightOption>;
-export declare const stringifySearchHighlightOption: (input: SearchHighlightOption) => string;
-export declare const assertStringifySearchHighlightOption: (input: unknown) => string;