@nxtedition/types 23.0.3 → 23.0.5

package/dist/common/date.d.ts

@@ -0,0 +1,8 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export type IsoTimestamp = string;
+export declare const isIsoTimestamp: (input: unknown) => input is string;
+export declare const assertIsoTimestamp: (input: unknown) => string;
+export declare const randomIsoTimestamp: () => string;
+export declare const assertGuardIsoTimestamp: __AssertionGuard<IsoTimestamp>;
+export declare const stringifyIsoTimestamp: (input: string) => string;
+export declare const assertStringifyIsoTimestamp: (input: unknown) => string;

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,10 +1,15 @@
 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';

package/dist/common/index.js

@@ -1,10 +1,15 @@
 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';

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/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;

package/dist/common/promoted-tag.js

@@ -0,0 +1,147 @@
+import __typia from "typia";
+export const isPromotedTag = input => {
+    const $io0 = input => (null === input.name || "string" === typeof input.name) && (null === input.icon || "string" === typeof input.icon) && (null === input.color || "string" === typeof input.color) && (null === input.description || "string" === typeof input.description);
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertPromotedTag = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (null === input.name || "string" === typeof input.name) && (null === input.icon || "string" === typeof input.icon) && (null === input.color || "string" === typeof input.color) && (null === input.description || "string" === typeof input.description);
+        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) => (null === input.name || "string" === typeof input.name || $guard(_exceptionable, {
+                path: _path + ".name",
+                expected: "(null | string)",
+                value: input.name
+            }, errorFactory)) && (null === input.icon || "string" === typeof input.icon || $guard(_exceptionable, {
+                path: _path + ".icon",
+                expected: "(null | string)",
+                value: input.icon
+            }, errorFactory)) && (null === input.color || "string" === typeof input.color || $guard(_exceptionable, {
+                path: _path + ".color",
+                expected: "(null | string)",
+                value: input.color
+            }, errorFactory)) && (null === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(null | string)",
+                value: input.description
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PromotedTag",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PromotedTag",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPromotedTag = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        name: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        icon: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        color: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        description: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardPromotedTag = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (null === input.name || "string" === typeof input.name) && (null === input.icon || "string" === typeof input.icon) && (null === input.color || "string" === typeof input.color) && (null === input.description || "string" === typeof input.description);
+        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) => (null === input.name || "string" === typeof input.name || $guard(_exceptionable, {
+                path: _path + ".name",
+                expected: "(null | string)",
+                value: input.name
+            }, errorFactory)) && (null === input.icon || "string" === typeof input.icon || $guard(_exceptionable, {
+                path: _path + ".icon",
+                expected: "(null | string)",
+                value: input.icon
+            }, errorFactory)) && (null === input.color || "string" === typeof input.color || $guard(_exceptionable, {
+                path: _path + ".color",
+                expected: "(null | string)",
+                value: input.color
+            }, errorFactory)) && (null === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(null | string)",
+                value: input.description
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PromotedTag",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PromotedTag",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPromotedTag = input => {
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{"name":${null !== input.name ? $string(input.name) : "null"},"icon":${null !== input.icon ? $string(input.icon) : "null"},"color":${null !== input.color ? $string(input.color) : "null"},"description":${null !== input.description ? $string(input.description) : "null"}}`;
+    return $so0(input);
+};
+export const assertStringifyPromotedTag = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (null === input.name || "string" === typeof input.name) && (null === input.icon || "string" === typeof input.icon) && (null === input.color || "string" === typeof input.color) && (null === input.description || "string" === typeof input.description);
+        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) => (null === input.name || "string" === typeof input.name || $guard(_exceptionable, {
+                path: _path + ".name",
+                expected: "(null | string)",
+                value: input.name
+            }, errorFactory)) && (null === input.icon || "string" === typeof input.icon || $guard(_exceptionable, {
+                path: _path + ".icon",
+                expected: "(null | string)",
+                value: input.icon
+            }, errorFactory)) && (null === input.color || "string" === typeof input.color || $guard(_exceptionable, {
+                path: _path + ".color",
+                expected: "(null | string)",
+                value: input.color
+            }, errorFactory)) && (null === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(null | string)",
+                value: input.description
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PromotedTag",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PromotedTag",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{"name":${null !== input.name ? $string(input.name) : "null"},"icon":${null !== input.icon ? $string(input.icon) : "null"},"color":${null !== input.color ? $string(input.color) : "null"},"description":${null !== input.description ? $string(input.description) : "null"}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/common/render-preset.d.ts

@@ -0,0 +1,32 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface RenderPreset {
+    type?: string;
+    description?: unknown;
+    profile?: string | RenderPresetProfile;
+}
+export declare const isRenderPreset: (input: unknown) => input is RenderPreset;
+export declare const assertRenderPreset: (input: unknown) => RenderPreset;
+export declare const randomRenderPreset: () => RenderPreset;
+export declare const assertGuardRenderPreset: __AssertionGuard<RenderPreset>;
+export declare const stringifyRenderPreset: (input: RenderPreset) => string;
+export declare const assertStringifyRenderPreset: (input: unknown) => string;
+export type RenderPresetProfileFormat = "png" | "mp4";
+export declare const isRenderPresetProfileFormat: (input: unknown) => input is RenderPresetProfileFormat;
+export declare const assertRenderPresetProfileFormat: (input: unknown) => RenderPresetProfileFormat;
+export declare const randomRenderPresetProfileFormat: () => RenderPresetProfileFormat;
+export declare const assertGuardRenderPresetProfileFormat: __AssertionGuard<RenderPresetProfileFormat>;
+export declare const stringifyRenderPresetProfileFormat: (input: RenderPresetProfileFormat) => string;
+export declare const assertStringifyRenderPresetProfileFormat: (input: unknown) => string;
+export interface RenderPresetProfile {
+    format: RenderPresetProfileFormat;
+    transcribe?: unknown;
+    audio?: unknown;
+    video?: unknown;
+    pick?: string[];
+}
+export declare const isRenderPresetProfile: (input: unknown) => input is RenderPresetProfile;
+export declare const assertRenderPresetProfile: (input: unknown) => RenderPresetProfile;
+export declare const randomRenderPresetProfile: () => RenderPresetProfile;
+export declare const assertGuardRenderPresetProfile: __AssertionGuard<RenderPresetProfile>;
+export declare const stringifyRenderPresetProfile: (input: RenderPresetProfile) => string;
+export declare const assertStringifyRenderPresetProfile: (input: unknown) => string;