@nxtedition/types 23.0.2 → 23.0.4

package/dist/common/date.js

@@ -0,0 +1,59 @@
+import __typia from "typia";
+export const isIsoTimestamp = input => {
+    return "string" === typeof input;
+};
+export const assertIsoTimestamp = (input, errorFactory) => {
+    const __is = input => {
+        return "string" === typeof input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            return "string" === typeof input || $guard(true, {
+                path: _path + "",
+                expected: "string",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomIsoTimestamp = generator => {
+    const $generator = __typia.createRandom.generator;
+    return (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)();
+};
+export const assertGuardIsoTimestamp = (input, errorFactory) => {
+    const __is = input => {
+        return "string" === typeof input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            return "string" === typeof input || $guard(true, {
+                path: _path + "",
+                expected: "string",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyIsoTimestamp = input => {
+    const $string = __typia.json.createStringify.string;
+    return $string(input);
+};
+export const assertStringifyIsoTimestamp = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "string" === typeof input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            return "string" === typeof input || $guard(true, {
+                path: _path + "",
+                expected: "string",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    return $string(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/common/index.d.ts

@@ -1,9 +1,17 @@
 import { type AssertionGuard as __AssertionGuard } from "typia";
 export * from './block.js';
+export * from './clone.js';
+export * from './date.js';
 export * from './file.js';
 export * from './location.js';
+export * from './nxtpression.js';
 export * from './lock.js';
+export * from './media.js';
+export * from './pipeline.js';
+export * from './promoted-tag.js';
+export * from './render-preset.js';
 export * from './rule.js';
+export * from './search.js';
 export * from './settings.js';
 export * from './error.js';
 export interface Message {

package/dist/common/index.js

@@ -1,9 +1,17 @@
 import __typia from "typia";
 export * from './block.js';
+export * from './clone.js';
+export * from './date.js';
 export * from './file.js';
 export * from './location.js';
+export * from './nxtpression.js';
 export * from './lock.js';
+export * from './media.js';
+export * from './pipeline.js';
+export * from './promoted-tag.js';
+export * from './render-preset.js';
 export * from './rule.js';
+export * from './search.js';
 export * from './settings.js';
 export * from './error.js';
 export const isMessage = input => {

package/dist/common/media.d.ts

@@ -0,0 +1,8 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export type MediaType = "audio" | "video" | "image";
+export declare const isMediaType: (input: unknown) => input is MediaType;
+export declare const assertMediaType: (input: unknown) => MediaType;
+export declare const randomMediaType: () => MediaType;
+export declare const assertGuardMediaType: __AssertionGuard<MediaType>;
+export declare const stringifyMediaType: (input: MediaType) => string;
+export declare const assertStringifyMediaType: (input: unknown) => string;

package/dist/common/media.js

@@ -0,0 +1,83 @@
+import __typia from "typia";
+export const isMediaType = input => {
+    return "audio" === input || "video" === input || "image" === input;
+};
+export const assertMediaType = (input, errorFactory) => {
+    const __is = input => {
+        return "audio" === input || "video" === input || "image" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            return "audio" === input || "video" === input || "image" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"audio\" | \"image\" | \"video\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomMediaType = generator => {
+    const $pick = __typia.createRandom.pick;
+    return $pick([
+        () => "audio",
+        () => "video",
+        () => "image"
+    ])();
+};
+export const assertGuardMediaType = (input, errorFactory) => {
+    const __is = input => {
+        return "audio" === input || "video" === input || "image" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            return "audio" === input || "video" === input || "image" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"audio\" | \"image\" | \"video\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyMediaType = input => {
+    const $string = __typia.json.createStringify.string;
+    const $throws = __typia.json.createStringify.throws;
+    return (() => {
+        if ("string" === typeof input)
+            return $string(input);
+        if ("string" === typeof input)
+            return "\"" + input + "\"";
+        $throws({
+            expected: "(\"audio\" | \"image\" | \"video\")",
+            value: input
+        });
+    })();
+};
+export const assertStringifyMediaType = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "audio" === input || "video" === input || "image" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            return "audio" === input || "video" === input || "image" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"audio\" | \"image\" | \"video\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $throws = __typia.json.createAssertStringify.throws;
+    return (() => {
+        if ("string" === typeof input)
+            return $string(input);
+        if ("string" === typeof input)
+            return "\"" + input + "\"";
+        $throws({
+            expected: "(\"audio\" | \"image\" | \"video\")",
+            value: input
+        });
+    })();
+}; return stringify(assert(input, errorFactory)); };

package/dist/common/nxtpression.d.ts

@@ -0,0 +1,19 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export type Nxtpression<ReturnValue = string, Context extends object = object> = String & {
+    /**
+     * TS-HACK: this property doesn't really exist on the nxtpression string,
+     * it is only here to make sure the generic Context won't get stripped.
+     */
+    __context?: Context;
+    /**
+     * TS-HACK: this property doesn't really exist on the nxtpression string,
+     * it is only here to make sure the generic Context won't get stripped.
+     */
+    __returnValue?: ReturnValue;
+};
+export declare const isNxtpression: (input: unknown) => input is Nxtpression<string, object>;
+export declare const assertNxtpression: (input: unknown) => Nxtpression<string, object>;
+export declare const randomNxtpression: () => string;
+export declare const assertGuardNxtpression: __AssertionGuard<Nxtpression>;
+export declare const stringifyNxtpression: (input: Nxtpression<string, object>) => string;
+export declare const assertStringifyNxtpression: (input: unknown) => string;

package/dist/common/nxtpression.js

@@ -0,0 +1,240 @@
+import __typia from "typia";
+export const isNxtpression = input => {
+    const $io0 = input => "number" === typeof input.length && (undefined === input.__context || "object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) && $io1(input.__context)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue) && Object.keys(input).every(key => {
+        if (["length", "__context", "__returnValue"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        if ("number" === typeof Number(key))
+            return "string" === typeof value;
+        return true;
+    });
+    const $io1 = input => true;
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertNxtpression = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => "number" === typeof input.length && (undefined === input.__context || "object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) && $io1(input.__context)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue) && Object.keys(input).every(key => {
+            if (["length", "__context", "__returnValue"].some(prop => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            if ("number" === typeof Number(key))
+                return "string" === typeof value;
+            return true;
+        });
+        const $io1 = input => true;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $join = __typia.createAssert.join;
+            const $ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.length || $guard(_exceptionable, {
+                path: _path + ".length",
+                expected: "number",
+                value: input.length
+            }, errorFactory)) && (undefined === input.__context || ("object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) || $guard(_exceptionable, {
+                path: _path + ".__context",
+                expected: "(object | undefined)",
+                value: input.__context
+            }, errorFactory)) && $ao1(input.__context, _path + ".__context", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".__context",
+                expected: "(object | undefined)",
+                value: input.__context
+            }, errorFactory)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue || $guard(_exceptionable, {
+                path: _path + ".__returnValue",
+                expected: "(string | undefined)",
+                value: input.__returnValue
+            }, errorFactory)) && (false === _exceptionable || Object.keys(input).every(key => {
+                if (["length", "__context", "__returnValue"].some(prop => key === prop))
+                    return true;
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                if ("number" === typeof Number(key))
+                    return "string" === typeof value || $guard(_exceptionable, {
+                        path: _path + $join(key),
+                        expected: "string",
+                        value: value
+                    }, errorFactory);
+                return true;
+            }));
+            const $ao1 = (input, _path, _exceptionable = true) => true;
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "Nxtpression<string, object>",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "Nxtpression<string, object>",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomNxtpression = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => {
+        const output = {
+            length: (generator?.customs ?? $generator.customs)?.number?.([]) ?? (generator?.number ?? $generator.number)(0, 100),
+            __context: $pick([
+                () => undefined,
+                () => $ro1(_recursive, _recursive ? 1 + _depth : _depth)
+            ])(),
+            __returnValue: $pick([
+                () => undefined,
+                () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+            ])()
+        };
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.number?.([]) ?? (generator?.number ?? $generator.number)(0, 100)] = (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    const $ro1 = (_recursive = false, _depth = 0) => {};
+    return $ro0();
+};
+export const assertGuardNxtpression = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => "number" === typeof input.length && (undefined === input.__context || "object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) && $io1(input.__context)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue) && Object.keys(input).every(key => {
+            if (["length", "__context", "__returnValue"].some(prop => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            if ("number" === typeof Number(key))
+                return "string" === typeof value;
+            return true;
+        });
+        const $io1 = input => true;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $join = __typia.createAssertGuard.join;
+            const $ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.length || $guard(_exceptionable, {
+                path: _path + ".length",
+                expected: "number",
+                value: input.length
+            }, errorFactory)) && (undefined === input.__context || ("object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) || $guard(_exceptionable, {
+                path: _path + ".__context",
+                expected: "(object | undefined)",
+                value: input.__context
+            }, errorFactory)) && $ao1(input.__context, _path + ".__context", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".__context",
+                expected: "(object | undefined)",
+                value: input.__context
+            }, errorFactory)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue || $guard(_exceptionable, {
+                path: _path + ".__returnValue",
+                expected: "(string | undefined)",
+                value: input.__returnValue
+            }, errorFactory)) && (false === _exceptionable || Object.keys(input).every(key => {
+                if (["length", "__context", "__returnValue"].some(prop => key === prop))
+                    return true;
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                if ("number" === typeof Number(key))
+                    return "string" === typeof value || $guard(_exceptionable, {
+                        path: _path + $join(key),
+                        expected: "string",
+                        value: value
+                    }, errorFactory);
+                return true;
+            }));
+            const $ao1 = (input, _path, _exceptionable = true) => true;
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "Nxtpression<string, object>",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "Nxtpression<string, object>",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyNxtpression = input => {
+    const $io1 = input => true;
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.__context ? "" : `"__context":${undefined !== input.__context ? "{}" : undefined},`}${undefined === input.__returnValue ? "" : `"__returnValue":${undefined !== input.__returnValue ? $string(input.__returnValue) : undefined},`}"length":${input.length},${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; if (["__context", "__returnValue", "length"].some(regular => regular === key))
+        return ""; if (RegExp(/^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(key))
+        return `${JSON.stringify(key)}:${$string(value)}`; return ""; }).filter(str => "" !== str).join(",")}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyNxtpression = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => "number" === typeof input.length && !Number.isNaN(input.length) && (undefined === input.__context || "object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) && $io1(input.__context)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue) && Object.keys(input).every(key => {
+            if (["length", "__context", "__returnValue"].some(prop => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            if ("number" === typeof Number(key) && !Number.isNaN(Number(key)))
+                return "string" === typeof value;
+            return true;
+        });
+        const $io1 = input => true;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $join = __typia.json.createAssertStringify.join;
+            const $ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.length && !Number.isNaN(input.length) || $guard(_exceptionable, {
+                path: _path + ".length",
+                expected: "number",
+                value: input.length
+            }, errorFactory)) && (undefined === input.__context || ("object" === typeof input.__context && null !== input.__context && false === Array.isArray(input.__context) || $guard(_exceptionable, {
+                path: _path + ".__context",
+                expected: "(object | undefined)",
+                value: input.__context
+            }, errorFactory)) && $ao1(input.__context, _path + ".__context", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".__context",
+                expected: "(object | undefined)",
+                value: input.__context
+            }, errorFactory)) && (undefined === input.__returnValue || "string" === typeof input.__returnValue || $guard(_exceptionable, {
+                path: _path + ".__returnValue",
+                expected: "(string | undefined)",
+                value: input.__returnValue
+            }, errorFactory)) && (false === _exceptionable || Object.keys(input).every(key => {
+                if (["length", "__context", "__returnValue"].some(prop => key === prop))
+                    return true;
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                if ("number" === typeof Number(key) && !Number.isNaN(Number(key)))
+                    return "string" === typeof value || $guard(_exceptionable, {
+                        path: _path + $join(key),
+                        expected: "string",
+                        value: value
+                    }, errorFactory);
+                return true;
+            }));
+            const $ao1 = (input, _path, _exceptionable = true) => true;
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "Nxtpression<string, object>",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "Nxtpression<string, object>",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => true;
+    const $string = __typia.json.createAssertStringify.string;
+    const $tail = __typia.json.createAssertStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.__context ? "" : `"__context":${undefined !== input.__context ? "{}" : undefined},`}${undefined === input.__returnValue ? "" : `"__returnValue":${undefined !== input.__returnValue ? $string(input.__returnValue) : undefined},`}"length":${input.length},${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; if (["__context", "__returnValue", "length"].some(regular => regular === key))
+        return ""; if (RegExp(/^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(key))
+        return `${JSON.stringify(key)}:${$string(value)}`; return ""; }).filter(str => "" !== str).join(",")}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/common/pipeline.d.ts

@@ -0,0 +1,8 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export type PipelineSortMode = "default" | "manual" | "az" | "za" | "newest" | "oldest" | "mostrecent" | "leastrecent";
+export declare const isPipelineSortMode: (input: unknown) => input is PipelineSortMode;
+export declare const assertPipelineSortMode: (input: unknown) => PipelineSortMode;
+export declare const randomPipelineSortMode: () => PipelineSortMode;
+export declare const assertGuardPipelineSortMode: __AssertionGuard<PipelineSortMode>;
+export declare const stringifyPipelineSortMode: (input: PipelineSortMode) => string;
+export declare const assertStringifyPipelineSortMode: (input: unknown) => string;

package/dist/common/pipeline.js

@@ -0,0 +1,88 @@
+import __typia from "typia";
+export const isPipelineSortMode = input => {
+    return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input;
+};
+export const assertPipelineSortMode = (input, errorFactory) => {
+    const __is = input => {
+        return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"az\" | \"default\" | \"leastrecent\" | \"manual\" | \"mostrecent\" | \"newest\" | \"oldest\" | \"za\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPipelineSortMode = generator => {
+    const $pick = __typia.createRandom.pick;
+    return $pick([
+        () => "default",
+        () => "manual",
+        () => "az",
+        () => "za",
+        () => "newest",
+        () => "oldest",
+        () => "mostrecent",
+        () => "leastrecent"
+    ])();
+};
+export const assertGuardPipelineSortMode = (input, errorFactory) => {
+    const __is = input => {
+        return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"az\" | \"default\" | \"leastrecent\" | \"manual\" | \"mostrecent\" | \"newest\" | \"oldest\" | \"za\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPipelineSortMode = input => {
+    const $string = __typia.json.createStringify.string;
+    const $throws = __typia.json.createStringify.throws;
+    return (() => {
+        if ("string" === typeof input)
+            return $string(input);
+        if ("string" === typeof input)
+            return "\"" + input + "\"";
+        $throws({
+            expected: "(\"az\" | \"default\" | \"leastrecent\" | \"manual\" | \"mostrecent\" | \"newest\" | \"oldest\" | \"za\")",
+            value: input
+        });
+    })();
+};
+export const assertStringifyPipelineSortMode = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            return "default" === input || "manual" === input || "az" === input || "za" === input || "newest" === input || "oldest" === input || "mostrecent" === input || "leastrecent" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"az\" | \"default\" | \"leastrecent\" | \"manual\" | \"mostrecent\" | \"newest\" | \"oldest\" | \"za\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $throws = __typia.json.createAssertStringify.throws;
+    return (() => {
+        if ("string" === typeof input)
+            return $string(input);
+        if ("string" === typeof input)
+            return "\"" + input + "\"";
+        $throws({
+            expected: "(\"az\" | \"default\" | \"leastrecent\" | \"manual\" | \"mostrecent\" | \"newest\" | \"oldest\" | \"za\")",
+            value: input
+        });
+    })();
+}; return stringify(assert(input, errorFactory)); };

package/dist/common/promoted-tag.d.ts

@@ -0,0 +1,13 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface PromotedTag {
+    name: string | null;
+    icon: string | null;
+    color: string | null;
+    description: string | null;
+}
+export declare const isPromotedTag: (input: unknown) => input is PromotedTag;
+export declare const assertPromotedTag: (input: unknown) => PromotedTag;
+export declare const randomPromotedTag: () => PromotedTag;
+export declare const assertGuardPromotedTag: __AssertionGuard<PromotedTag>;
+export declare const stringifyPromotedTag: (input: PromotedTag) => string;
+export declare const assertStringifyPromotedTag: (input: unknown) => string;