@nxtedition/types 1.6.14 → 23.0.1

package/dist/domains/bundle.d.ts

@@ -0,0 +1,25 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface BundleDomainRecords {
+    [":bundle"]: BundleRecord;
+    [":bundle.revisions"]: BundleRevisionsRecord;
+}
+export interface BundleRecord {
+    user?: string;
+    description?: string;
+    files: Record<string, string>;
+}
+export declare const isBundleRecord: (input: unknown) => input is BundleRecord;
+export declare const assertBundleRecord: (input: unknown) => BundleRecord;
+export declare const randomBundleRecord: () => BundleRecord;
+export declare const assertGuardBundleRecord: __AssertionGuard<BundleRecord>;
+export declare const stringifyBundleRecord: (input: BundleRecord) => string;
+export declare const assertStringifyBundleRecord: (input: unknown) => string;
+export interface BundleRevisionsRecord {
+    [revisionId: string]: BundleRecord;
+}
+export declare const isBundleRevisionsRecord: (input: unknown) => input is BundleRevisionsRecord;
+export declare const assertBundleRevisionsRecord: (input: unknown) => BundleRevisionsRecord;
+export declare const randomBundleRevisionsRecord: () => BundleRevisionsRecord;
+export declare const assertGuardBundleRevisionsRecord: __AssertionGuard<BundleRevisionsRecord>;
+export declare const stringifyBundleRevisionsRecord: (input: BundleRevisionsRecord) => string;
+export declare const assertStringifyBundleRevisionsRecord: (input: unknown) => string;

package/dist/domains/bundle.js

@@ -0,0 +1,512 @@
+import __typia from "typia";
+export const isBundleRecord = input => {
+    const $io0 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io1(input.files));
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertBundleRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io1(input.files));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        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) => (undefined === input.user || "string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "(string | undefined)",
+                value: input.user
+            }, errorFactory)) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(string | undefined)",
+                value: input.description
+            }, errorFactory)) && (("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory)) && $ao1(input.files, _path + ".files", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory));
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "BundleRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomBundleRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        user: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        description: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        files: $ro1(_recursive, _recursive ? 1 + _depth : _depth)
+    });
+    const $ro1 = (_recursive = false, _depth = 0) => {
+        const output = {};
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()] = (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    return $ro0();
+};
+export const assertGuardBundleRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io1(input.files));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        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) => (undefined === input.user || "string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "(string | undefined)",
+                value: input.user
+            }, errorFactory)) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(string | undefined)",
+                value: input.description
+            }, errorFactory)) && (("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory)) && $ao1(input.files, _path + ".files", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory));
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "BundleRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyBundleRecord = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{${undefined === input.user ? "" : `"user":${undefined !== input.user ? $string(input.user) : undefined},`}${undefined === input.description ? "" : `"description":${undefined !== input.description ? $string(input.description) : undefined},`}"files":${$so1(input.files)}}`;
+    const $so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$string(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+};
+export const assertStringifyBundleRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io1(input.files));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        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) => (undefined === input.user || "string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "(string | undefined)",
+                value: input.user
+            }, errorFactory)) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(string | undefined)",
+                value: input.description
+            }, errorFactory)) && (("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory)) && $ao1(input.files, _path + ".files", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory));
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "BundleRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{${undefined === input.user ? "" : `"user":${undefined !== input.user ? $string(input.user) : undefined},`}${undefined === input.description ? "" : `"description":${undefined !== input.description ? $string(input.description) : undefined},`}"files":${$so1(input.files)}}`;
+    const $so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$string(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isBundleRevisionsRecord = input => {
+    const $io0 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && $io1(value);
+    });
+    const $io1 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io2(input.files));
+    const $io2 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertBundleRevisionsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && $io1(value);
+        });
+        const $io1 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io2(input.files));
+        const $io2 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        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 $join = __typia.createAssert.join;
+            const $ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "BundleRecord",
+                    value: value
+                }, errorFactory)) && $ao1(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "BundleRecord",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao1 = (input, _path, _exceptionable = true) => (undefined === input.user || "string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "(string | undefined)",
+                value: input.user
+            }, errorFactory)) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(string | undefined)",
+                value: input.description
+            }, errorFactory)) && (("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory)) && $ao2(input.files, _path + ".files", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory));
+            const $ao2 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRevisionsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRevisionsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomBundleRevisionsRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => {
+        const output = {};
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()] = $ro1(_recursive, _recursive ? 1 + _depth : _depth), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    const $ro1 = (_recursive = false, _depth = 0) => ({
+        user: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        description: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        files: $ro2(_recursive, _recursive ? 1 + _depth : _depth)
+    });
+    const $ro2 = (_recursive = false, _depth = 0) => {
+        const output = {};
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()] = (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    return $ro0();
+};
+export const assertGuardBundleRevisionsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && $io1(value);
+        });
+        const $io1 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io2(input.files));
+        const $io2 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        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 $join = __typia.createAssertGuard.join;
+            const $ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "BundleRecord",
+                    value: value
+                }, errorFactory)) && $ao1(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "BundleRecord",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao1 = (input, _path, _exceptionable = true) => (undefined === input.user || "string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "(string | undefined)",
+                value: input.user
+            }, errorFactory)) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(string | undefined)",
+                value: input.description
+            }, errorFactory)) && (("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory)) && $ao2(input.files, _path + ".files", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory));
+            const $ao2 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRevisionsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRevisionsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyBundleRevisionsRecord = input => {
+    const $io1 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io2(input.files));
+    const $io2 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$so1(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    const $so1 = input => `{${undefined === input.user ? "" : `"user":${undefined !== input.user ? $string(input.user) : undefined},`}${undefined === input.description ? "" : `"description":${undefined !== input.description ? $string(input.description) : undefined},`}"files":${$so2(input.files)}}`;
+    const $so2 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$string(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+};
+export const assertStringifyBundleRevisionsRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && $io1(value);
+        });
+        const $io1 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io2(input.files));
+        const $io2 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        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 $join = __typia.json.createAssertStringify.join;
+            const $ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "BundleRecord",
+                    value: value
+                }, errorFactory)) && $ao1(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "BundleRecord",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao1 = (input, _path, _exceptionable = true) => (undefined === input.user || "string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "(string | undefined)",
+                value: input.user
+            }, errorFactory)) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                path: _path + ".description",
+                expected: "(string | undefined)",
+                value: input.description
+            }, errorFactory)) && (("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory)) && $ao2(input.files, _path + ".files", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".files",
+                expected: "Record<string, string>",
+                value: input.files
+            }, errorFactory));
+            const $ao2 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRevisionsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "BundleRevisionsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => (undefined === input.user || "string" === typeof input.user) && (undefined === input.description || "string" === typeof input.description) && ("object" === typeof input.files && null !== input.files && false === Array.isArray(input.files) && $io2(input.files));
+    const $io2 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$so1(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    const $so1 = input => `{${undefined === input.user ? "" : `"user":${undefined !== input.user ? $string(input.user) : undefined},`}${undefined === input.description ? "" : `"description":${undefined !== input.description ? $string(input.description) : undefined},`}"files":${$so2(input.files)}}`;
+    const $so2 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$string(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/index.d.ts

@@ -1,4 +1,5 @@
 import type { AssetDomainRecords } from './asset.js';
+import type { BundleDomainRecords } from './bundle.js';
 import type { ConnectionDomainRecords } from './connection.js';
 import type { ContactDomainRecords } from './contact.js';
 import type { EventDomainRecords } from './event.js';
@@ -14,6 +15,7 @@ import type { SearchDomainRecords } from './search.js';
 import type { SettingsDomainRecords } from './settings.js';
 import type { TemplateDomainRecords } from './template.js';
 export * from './asset.js';
+export * from './bundle.js';
 export * from './connection.js';
 export * from './contact.js';
 export * from './event.js';
@@ -28,4 +30,4 @@ export * from './script.js';
 export * from './search.js';
 export * from './settings.js';
 export * from './template.js';
-export type DomainRecords = AssetDomainRecords & ConnectionDomainRecords & ContactDomainRecords & EventDomainRecords & FileDomainRecords & GeneralDomainRecords & MediaDomainRecords & PermissionDomainRecords & PlanningDomainRecords & PublishDomainRecords & RoleDomainRecords & ScriptDomainRecords & SearchDomainRecords & SettingsDomainRecords & TemplateDomainRecords;
+export type DomainRecords = AssetDomainRecords & BundleDomainRecords & ConnectionDomainRecords & ContactDomainRecords & EventDomainRecords & FileDomainRecords & GeneralDomainRecords & MediaDomainRecords & PermissionDomainRecords & PlanningDomainRecords & PublishDomainRecords & RoleDomainRecords & ScriptDomainRecords & SearchDomainRecords & SettingsDomainRecords & TemplateDomainRecords;

package/dist/domains/index.js

@@ -1,4 +1,5 @@
 export * from './asset.js';
+export * from './bundle.js';
 export * from './connection.js';
 export * from './contact.js';
 export * from './event.js';

package/dist/domains/media.d.ts

@@ -1,8 +1,10 @@
 import { type AssertionGuard as __AssertionGuard } from "typia";
+import type { Operation } from 'rfc6902';
 export interface MediaDomainRecords {
     ":media.source": MediaSourceRecord;
     ":media.consolidate": MediaConsolidateRecord;
     ":media.renders?": MediaRendersRecord;
+    ":media.transcriptChanges": MediaTranscriptChangesRecord;
 }
 export interface MediaSourceRecord {
     input?: {
@@ -64,3 +66,21 @@ export declare const randomMediaRenderRecordValue: () => MediaRenderRecordValue;
 export declare const assertGuardMediaRenderRecordValue: __AssertionGuard<MediaRenderRecordValue>;
 export declare const stringifyMediaRenderRecordValue: (input: MediaRenderRecordValue) => string;
 export declare const assertStringifyMediaRenderRecordValue: (input: unknown) => string;
+export type MediaTranscriptChangesRecord = {
+    [patchKey: string]: MediaTranscriptChangesRecordValue;
+};
+export declare const isMediaTranscriptChangesRecord: (input: unknown) => input is MediaTranscriptChangesRecord;
+export declare const assertMediaTranscriptChangesRecord: (input: unknown) => MediaTranscriptChangesRecord;
+export declare const randomMediaTranscriptChangesRecord: () => MediaTranscriptChangesRecord;
+export declare const assertGuardMediaTranscriptChangesRecord: __AssertionGuard<MediaTranscriptChangesRecord>;
+export declare const stringifyMediaTranscriptChangesRecord: (input: MediaTranscriptChangesRecord) => string;
+export declare const assertStringifyMediaTranscriptChangesRecord: (input: unknown) => string;
+export interface MediaTranscriptChangesRecordValue {
+    patch?: Operation[];
+}
+export declare const isMediaTranscriptChangesRecordValue: (input: unknown) => input is MediaTranscriptChangesRecordValue;
+export declare const assertMediaTranscriptChangesRecordValue: (input: unknown) => MediaTranscriptChangesRecordValue;
+export declare const randomMediaTranscriptChangesRecordValue: () => MediaTranscriptChangesRecordValue;
+export declare const assertGuardMediaTranscriptChangesRecordValue: __AssertionGuard<MediaTranscriptChangesRecordValue>;
+export declare const stringifyMediaTranscriptChangesRecordValue: (input: MediaTranscriptChangesRecordValue) => string;
+export declare const assertStringifyMediaTranscriptChangesRecordValue: (input: unknown) => string;