@nxtedition/types 1.0.0

package/dist/domains/role.d.ts

@@ -0,0 +1,13 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface RoleDomainRecords {
+    ":role.tags": RoleTagsRecord;
+}
+export interface RoleTagsRecord {
+    value: string[];
+}
+export declare const isRoleTagsRecord: (input: unknown) => input is RoleTagsRecord;
+export declare const assertRoleTagsRecord: (input: unknown) => RoleTagsRecord;
+export declare const randomRoleTagsRecord: () => RoleTagsRecord;
+export declare const assertGuardRoleTagsRecord: __AssertionGuard<RoleTagsRecord>;
+export declare const stringifyRoleTagsRecord: (input: RoleTagsRecord) => string;
+export declare const assertStringifyRoleTagsRecord: (input: unknown) => string;

package/dist/domains/role.js

@@ -0,0 +1,119 @@
+import __typia from "typia";
+export const isRoleTagsRecord = input => {
+    const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertRoleTagsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.value) && input.value.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.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "RoleTagsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RoleTagsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomRoleTagsRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+    });
+    return $ro0();
+};
+export const assertGuardRoleTagsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.value) && input.value.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.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "RoleTagsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RoleTagsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyRoleTagsRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{"value":${`[${input.value.map(elem => $string(elem)).join(",")}]`}}`;
+    return $so0(input);
+};
+export const assertStringifyRoleTagsRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.value) && input.value.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.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "RoleTagsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RoleTagsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{"value":${`[${input.value.map(elem => $string(elem)).join(",")}]`}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/script.d.ts

@@ -0,0 +1,13 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface ScriptDomainRecords {
+    ":script.children": ScriptChildrenRecord;
+}
+export interface ScriptChildrenRecord {
+    value?: string[];
+}
+export declare const isScriptChildrenRecord: (input: unknown) => input is ScriptChildrenRecord;
+export declare const assertScriptChildrenRecord: (input: unknown) => ScriptChildrenRecord;
+export declare const randomScriptChildrenRecord: () => ScriptChildrenRecord;
+export declare const assertGuardScriptChildrenRecord: __AssertionGuard<ScriptChildrenRecord>;
+export declare const stringifyScriptChildrenRecord: (input: ScriptChildrenRecord) => string;
+export declare const assertStringifyScriptChildrenRecord: (input: unknown) => string;

package/dist/domains/script.js

@@ -0,0 +1,125 @@
+import __typia from "typia";
+export const isScriptChildrenRecord = input => {
+    const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertScriptChildrenRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<string> | undefined)",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<string> | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "ScriptChildrenRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "ScriptChildrenRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomScriptChildrenRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: $pick([
+            () => undefined,
+            () => (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardScriptChildrenRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<string> | undefined)",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<string> | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "ScriptChildrenRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "ScriptChildrenRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyScriptChildrenRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.value ? "" : `"value":${undefined !== input.value ? `[${input.value.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyScriptChildrenRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<string> | undefined)",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<string> | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "ScriptChildrenRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "ScriptChildrenRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $tail = __typia.json.createAssertStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.value ? "" : `"value":${undefined !== input.value ? `[${input.value.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/search.d.ts

@@ -0,0 +1,13 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface SearchDomainRecords {
+    ":search": SearchRecord;
+}
+export interface SearchRecord {
+    hits: string[];
+}
+export declare const isSearchRecord: (input: unknown) => input is SearchRecord;
+export declare const assertSearchRecord: (input: unknown) => SearchRecord;
+export declare const randomSearchRecord: () => SearchRecord;
+export declare const assertGuardSearchRecord: __AssertionGuard<SearchRecord>;
+export declare const stringifySearchRecord: (input: SearchRecord) => string;
+export declare const assertStringifySearchRecord: (input: unknown) => string;

package/dist/domains/search.js

@@ -0,0 +1,119 @@
+import __typia from "typia";
+export const isSearchRecord = input => {
+    const $io0 = input => Array.isArray(input.hits) && input.hits.every(elem => "string" === typeof elem);
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertSearchRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.hits) && input.hits.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.hits) || $guard(_exceptionable, {
+                path: _path + ".hits",
+                expected: "Array<string>",
+                value: input.hits
+            }, errorFactory)) && input.hits.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".hits[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".hits",
+                expected: "Array<string>",
+                value: input.hits
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "SearchRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "SearchRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomSearchRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        hits: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+    });
+    return $ro0();
+};
+export const assertGuardSearchRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.hits) && input.hits.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.hits) || $guard(_exceptionable, {
+                path: _path + ".hits",
+                expected: "Array<string>",
+                value: input.hits
+            }, errorFactory)) && input.hits.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".hits[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".hits",
+                expected: "Array<string>",
+                value: input.hits
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "SearchRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "SearchRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifySearchRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{"hits":${`[${input.hits.map(elem => $string(elem)).join(",")}]`}}`;
+    return $so0(input);
+};
+export const assertStringifySearchRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.hits) && input.hits.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.hits) || $guard(_exceptionable, {
+                path: _path + ".hits",
+                expected: "Array<string>",
+                value: input.hits
+            }, errorFactory)) && input.hits.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".hits[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".hits",
+                expected: "Array<string>",
+                value: input.hits
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "SearchRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "SearchRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{"hits":${`[${input.hits.map(elem => $string(elem)).join(",")}]`}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/settings.d.ts

@@ -0,0 +1,13 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+import type { Settings } from '../common/index.js';
+import type { PartialDeep } from 'type-fest';
+export interface SettingsDomainRecords {
+    ":settings": SettingsRecord;
+}
+export type SettingsRecord = PartialDeep<Settings>;
+export declare const isSettingsRecord: (input: unknown) => input is import("type-fest/source/partial-deep.js").PartialObjectDeep<Settings, {}>;
+export declare const assertSettingsRecord: (input: unknown) => import("type-fest/source/partial-deep.js").PartialObjectDeep<Settings, {}>;
+export declare const randomSettingsRecord: () => import("type-fest/source/partial-deep.js").PartialObjectDeep<Settings, {}>;
+export declare const assertGuardSettingsRecord: __AssertionGuard<SettingsRecord>;
+export declare const stringifySettingsRecord: (input: import("type-fest/source/partial-deep.js").PartialObjectDeep<Settings, {}>) => string;
+export declare const assertStringifySettingsRecord: (input: unknown) => string;