@nxtedition/types 23.0.12 → 23.0.13

package/dist/common/user-notification.d.ts

@@ -0,0 +1,8 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export type NotificationReason = "mentioned" | "assigned" | "author" | "participated" | "always";
+export declare const isNotificationReason: (input: unknown) => input is NotificationReason;
+export declare const assertNotificationReason: (input: unknown) => NotificationReason;
+export declare const randomNotificationReason: () => NotificationReason;
+export declare const assertGuardNotificationReason: __AssertionGuard<NotificationReason>;
+export declare const stringifyNotificationReason: (input: NotificationReason) => string;
+export declare const assertStringifyNotificationReason: (input: unknown) => string;

package/dist/common/user-notification.js

@@ -0,0 +1,85 @@
+import __typia from "typia";
+export const isNotificationReason = input => {
+    return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input;
+};
+export const assertNotificationReason = (input, errorFactory) => {
+    const __is = input => {
+        return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"always\" | \"assigned\" | \"author\" | \"mentioned\" | \"participated\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomNotificationReason = generator => {
+    const $pick = __typia.createRandom.pick;
+    return $pick([
+        () => "mentioned",
+        () => "assigned",
+        () => "author",
+        () => "participated",
+        () => "always"
+    ])();
+};
+export const assertGuardNotificationReason = (input, errorFactory) => {
+    const __is = input => {
+        return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"always\" | \"assigned\" | \"author\" | \"mentioned\" | \"participated\")",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyNotificationReason = 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: "(\"always\" | \"assigned\" | \"author\" | \"mentioned\" | \"participated\")",
+            value: input
+        });
+    })();
+};
+export const assertStringifyNotificationReason = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input;
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            return "mentioned" === input || "assigned" === input || "author" === input || "participated" === input || "always" === input || $guard(true, {
+                path: _path + "",
+                expected: "(\"always\" | \"assigned\" | \"author\" | \"mentioned\" | \"participated\")",
+                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: "(\"always\" | \"assigned\" | \"author\" | \"mentioned\" | \"participated\")",
+            value: input
+        });
+    })();
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/asset.d.ts

@@ -19,6 +19,8 @@ export interface AssetDomainRecords {
     ":asset.controllers?": AssetDomainControllersProvidedRecord;
     ":asset.embedding?": AssetDomainEmbeddingProvidedRecord;
     ":asset.media?": AssetDomainMediaProvidedRecord;
+    ":asset.presence?": AssetDomainPresenceProvidedRecord;
+    ":asset.comments?": AssetCommentsRecord;
 }
 export interface AssetTitleProvidedRecord {
     value?: string;
@@ -201,4 +203,25 @@ export declare const randomAssetDomainMediaProvidedRecord: () => AssetDomainMedi
 export declare const assertGuardAssetDomainMediaProvidedRecord: __AssertionGuard<AssetDomainMediaProvidedRecord>;
 export declare const stringifyAssetDomainMediaProvidedRecord: (input: AssetDomainMediaProvidedRecord) => string;
 export declare const assertStringifyAssetDomainMediaProvidedRecord: (input: unknown) => string;
+export interface AssetDomainPresenceProvidedRecord {
+    value?: string[];
+}
+export declare const isAssetDomainPresenceProvidedRecord: (input: unknown) => input is AssetDomainPresenceProvidedRecord;
+export declare const assertAssetDomainPresenceProvidedRecord: (input: unknown) => AssetDomainPresenceProvidedRecord;
+export declare const randomAssetDomainPresenceProvidedRecord: () => AssetDomainPresenceProvidedRecord;
+export declare const assertGuardAssetDomainPresenceProvidedRecord: __AssertionGuard<AssetDomainPresenceProvidedRecord>;
+export declare const stringifyAssetDomainPresenceProvidedRecord: (input: AssetDomainPresenceProvidedRecord) => string;
+export declare const assertStringifyAssetDomainPresenceProvidedRecord: (input: unknown) => string;
+export interface AssetCommentsRecord {
+    /**
+     * IDs of comment assets associated with the asset.
+     */
+    value?: string[];
+}
+export declare const isAssetCommentsRecord: (input: unknown) => input is AssetCommentsRecord;
+export declare const assertAssetCommentsRecord: (input: unknown) => AssetCommentsRecord;
+export declare const randomAssetCommentsRecord: () => AssetCommentsRecord;
+export declare const assertGuardAssetCommentsRecord: __AssertionGuard<AssetCommentsRecord>;
+export declare const stringifyAssetCommentsRecord: (input: AssetCommentsRecord) => string;
+export declare const assertStringifyAssetCommentsRecord: (input: unknown) => string;
 export {};

package/dist/domains/asset.js

@@ -2422,3 +2422,251 @@ export const assertStringifyAssetDomainMediaProvidedRecord = (input, errorFactor
         return ""; return `${JSON.stringify(key)}:${undefined !== value ? JSON.stringify(value) : undefined}`; }).filter(str => "" !== str).join(",")}}`;
     return $so0(input);
 }; return stringify(assert(input, errorFactory)); };
+export const isAssetDomainPresenceProvidedRecord = 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 assertAssetDomainPresenceProvidedRecord = (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: "AssetDomainPresenceProvidedRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetDomainPresenceProvidedRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomAssetDomainPresenceProvidedRecord = 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 assertGuardAssetDomainPresenceProvidedRecord = (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: "AssetDomainPresenceProvidedRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetDomainPresenceProvidedRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyAssetDomainPresenceProvidedRecord = 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 assertStringifyAssetDomainPresenceProvidedRecord = (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: "AssetDomainPresenceProvidedRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetDomainPresenceProvidedRecord",
+                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)); };
+export const isAssetCommentsRecord = 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 assertAssetCommentsRecord = (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: "AssetCommentsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetCommentsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomAssetCommentsRecord = 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 assertGuardAssetCommentsRecord = (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: "AssetCommentsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetCommentsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyAssetCommentsRecord = 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 assertStringifyAssetCommentsRecord = (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: "AssetCommentsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetCommentsRecord",
+                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/comment-reaction.d.ts

@@ -0,0 +1,15 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface CommentReactionDomainRecords {
+    "comment-reaction": CommentReactionDomainRecord;
+}
+export interface CommentReactionDomainRecord {
+    comment: string;
+    user: string;
+    reaction: string;
+}
+export declare const isCommentReactionDomainRecord: (input: unknown) => input is CommentReactionDomainRecord;
+export declare const assertCommentReactionDomainRecord: (input: unknown) => CommentReactionDomainRecord;
+export declare const randomCommentReactionDomainRecord: () => CommentReactionDomainRecord;
+export declare const assertGuardCommentReactionDomainRecord: __AssertionGuard<CommentReactionDomainRecord>;
+export declare const stringifyCommentReactionDomainRecord: (input: CommentReactionDomainRecord) => string;
+export declare const assertStringifyCommentReactionDomainRecord: (input: unknown) => string;

package/dist/domains/comment-reaction.js

@@ -0,0 +1,115 @@
+import __typia from "typia";
+export const isCommentReactionDomainRecord = input => {
+    return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.reaction);
+};
+export const assertCommentReactionDomainRecord = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.reaction);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.comment || $guard(_exceptionable, {
+                path: _path + ".comment",
+                expected: "string",
+                value: input.comment
+            }, errorFactory)) && ("string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "string",
+                value: input.user
+            }, errorFactory)) && ("string" === typeof input.reaction || $guard(_exceptionable, {
+                path: _path + ".reaction",
+                expected: "string",
+                value: input.reaction
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "CommentReactionDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "CommentReactionDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomCommentReactionDomainRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        comment: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        user: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        reaction: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+    });
+    return $ro0();
+};
+export const assertGuardCommentReactionDomainRecord = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.reaction);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.comment || $guard(_exceptionable, {
+                path: _path + ".comment",
+                expected: "string",
+                value: input.comment
+            }, errorFactory)) && ("string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "string",
+                value: input.user
+            }, errorFactory)) && ("string" === typeof input.reaction || $guard(_exceptionable, {
+                path: _path + ".reaction",
+                expected: "string",
+                value: input.reaction
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "CommentReactionDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "CommentReactionDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyCommentReactionDomainRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    return `{"comment":${$string(input.comment)},"user":${$string(input.user)},"reaction":${$string(input.reaction)}}`;
+};
+export const assertStringifyCommentReactionDomainRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.reaction);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.comment || $guard(_exceptionable, {
+                path: _path + ".comment",
+                expected: "string",
+                value: input.comment
+            }, errorFactory)) && ("string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "string",
+                value: input.user
+            }, errorFactory)) && ("string" === typeof input.reaction || $guard(_exceptionable, {
+                path: _path + ".reaction",
+                expected: "string",
+                value: input.reaction
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "CommentReactionDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "CommentReactionDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    return `{"comment":${$string(input.comment)},"user":${$string(input.user)},"reaction":${$string(input.reaction)}}`;
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/comment-read-mark.d.ts

@@ -0,0 +1,15 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface CommentReadMarkDomainRecords {
+    "comment-read-mark": CommentReadMarkDomainRecord;
+}
+export interface CommentReadMarkDomainRecord {
+    comment: string;
+    user: string;
+    time: string;
+}
+export declare const isCommentReadMarkDomainRecord: (input: unknown) => input is CommentReadMarkDomainRecord;
+export declare const assertCommentReadMarkDomainRecord: (input: unknown) => CommentReadMarkDomainRecord;
+export declare const randomCommentReadMarkDomainRecord: () => CommentReadMarkDomainRecord;
+export declare const assertGuardCommentReadMarkDomainRecord: __AssertionGuard<CommentReadMarkDomainRecord>;
+export declare const stringifyCommentReadMarkDomainRecord: (input: CommentReadMarkDomainRecord) => string;
+export declare const assertStringifyCommentReadMarkDomainRecord: (input: unknown) => string;

package/dist/domains/comment-read-mark.js

@@ -0,0 +1,115 @@
+import __typia from "typia";
+export const isCommentReadMarkDomainRecord = input => {
+    return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.time);
+};
+export const assertCommentReadMarkDomainRecord = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.time);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.comment || $guard(_exceptionable, {
+                path: _path + ".comment",
+                expected: "string",
+                value: input.comment
+            }, errorFactory)) && ("string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "string",
+                value: input.user
+            }, errorFactory)) && ("string" === typeof input.time || $guard(_exceptionable, {
+                path: _path + ".time",
+                expected: "string",
+                value: input.time
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "CommentReadMarkDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "CommentReadMarkDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomCommentReadMarkDomainRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        comment: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        user: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        time: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+    });
+    return $ro0();
+};
+export const assertGuardCommentReadMarkDomainRecord = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.time);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.comment || $guard(_exceptionable, {
+                path: _path + ".comment",
+                expected: "string",
+                value: input.comment
+            }, errorFactory)) && ("string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "string",
+                value: input.user
+            }, errorFactory)) && ("string" === typeof input.time || $guard(_exceptionable, {
+                path: _path + ".time",
+                expected: "string",
+                value: input.time
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "CommentReadMarkDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "CommentReadMarkDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyCommentReadMarkDomainRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    return `{"comment":${$string(input.comment)},"user":${$string(input.user)},"time":${$string(input.time)}}`;
+};
+export const assertStringifyCommentReadMarkDomainRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("string" === typeof input.comment && "string" === typeof input.user && "string" === typeof input.time);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.comment || $guard(_exceptionable, {
+                path: _path + ".comment",
+                expected: "string",
+                value: input.comment
+            }, errorFactory)) && ("string" === typeof input.user || $guard(_exceptionable, {
+                path: _path + ".user",
+                expected: "string",
+                value: input.user
+            }, errorFactory)) && ("string" === typeof input.time || $guard(_exceptionable, {
+                path: _path + ".time",
+                expected: "string",
+                value: input.time
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "CommentReadMarkDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "CommentReadMarkDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    return `{"comment":${$string(input.comment)},"user":${$string(input.user)},"time":${$string(input.time)}}`;
+}; return stringify(assert(input, errorFactory)); };