@nxtedition/types 23.0.12 → 23.0.14

package/dist/domains/user.d.ts

@@ -1,14 +1,48 @@
 import { type AssertionGuard as __AssertionGuard } from "typia";
 export interface UserDomainRecords {
-    ":user": UserRecord;
+    ":user": UserDomainRecord;
+    ":user.latestSeenNotification": UserDomainLatestSeenNotificationRecord;
+    ":user.receivedNotifications?": UserDomainReceivedNotificationsProvidedRecord;
+    ":user.unseenNotifications?": UserDomainUnseenNotificationsRecord;
 }
-export interface UserRecord {
+export interface UserDomainRecord {
     username?: string;
     roles?: string[];
 }
-export declare const isUserRecord: (input: unknown) => input is UserRecord;
-export declare const assertUserRecord: (input: unknown) => UserRecord;
-export declare const randomUserRecord: () => UserRecord;
-export declare const assertGuardUserRecord: __AssertionGuard<UserRecord>;
-export declare const stringifyUserRecord: (input: UserRecord) => string;
-export declare const assertStringifyUserRecord: (input: unknown) => string;
+export declare const isUserDomainRecord: (input: unknown) => input is UserDomainRecord;
+export declare const assertUserDomainRecord: (input: unknown) => UserDomainRecord;
+export declare const randomUserDomainRecord: () => UserDomainRecord;
+export declare const assertGuardUserDomainRecord: __AssertionGuard<UserDomainRecord>;
+export declare const stringifyUserDomainRecord: (input: UserDomainRecord) => string;
+export declare const assertStringifyUserDomainRecord: (input: unknown) => string;
+export interface UserDomainLatestSeenNotificationRecord {
+    value?: string;
+}
+export declare const isUserDomainLatestSeenNotificationRecord: (input: unknown) => input is UserDomainLatestSeenNotificationRecord;
+export declare const assertUserDomainLatestSeenNotificationRecord: (input: unknown) => UserDomainLatestSeenNotificationRecord;
+export declare const randomUserDomainLatestSeenNotificationRecord: () => UserDomainLatestSeenNotificationRecord;
+export declare const assertGuardUserDomainLatestSeenNotificationRecord: __AssertionGuard<UserDomainLatestSeenNotificationRecord>;
+export declare const stringifyUserDomainLatestSeenNotificationRecord: (input: UserDomainLatestSeenNotificationRecord) => string;
+export declare const assertStringifyUserDomainLatestSeenNotificationRecord: (input: unknown) => string;
+export interface UserDomainReceivedNotificationsProvidedRecord {
+    /**
+     * IDs of notifications the user has received.
+     */
+    value?: string[];
+}
+export declare const isUserDomainReceivedNotificationsProvidedRecord: (input: unknown) => input is UserDomainReceivedNotificationsProvidedRecord;
+export declare const assertUserDomainReceivedNotificationsProvidedRecord: (input: unknown) => UserDomainReceivedNotificationsProvidedRecord;
+export declare const randomUserDomainReceivedNotificationsProvidedRecord: () => UserDomainReceivedNotificationsProvidedRecord;
+export declare const assertGuardUserDomainReceivedNotificationsProvidedRecord: __AssertionGuard<UserDomainReceivedNotificationsProvidedRecord>;
+export declare const stringifyUserDomainReceivedNotificationsProvidedRecord: (input: UserDomainReceivedNotificationsProvidedRecord) => string;
+export declare const assertStringifyUserDomainReceivedNotificationsProvidedRecord: (input: unknown) => string;
+export interface UserDomainUnseenNotificationsRecord {
+    hasUnseen?: boolean;
+    latestReceived?: string;
+}
+export declare const isUserDomainUnseenNotificationsRecord: (input: unknown) => input is UserDomainUnseenNotificationsRecord;
+export declare const assertUserDomainUnseenNotificationsRecord: (input: unknown) => UserDomainUnseenNotificationsRecord;
+export declare const randomUserDomainUnseenNotificationsRecord: () => UserDomainUnseenNotificationsRecord;
+export declare const assertGuardUserDomainUnseenNotificationsRecord: __AssertionGuard<UserDomainUnseenNotificationsRecord>;
+export declare const stringifyUserDomainUnseenNotificationsRecord: (input: UserDomainUnseenNotificationsRecord) => string;
+export declare const assertStringifyUserDomainUnseenNotificationsRecord: (input: unknown) => string;

package/dist/domains/user.js

@@ -1,9 +1,9 @@
 import __typia from "typia";
-export const isUserRecord = input => {
+export const isUserDomainRecord = input => {
     const $io0 = input => (undefined === input.username || "string" === typeof input.username) && (undefined === input.roles || Array.isArray(input.roles) && input.roles.every(elem => "string" === typeof elem));
     return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
 };
-export const assertUserRecord = (input, errorFactory) => {
+export const assertUserDomainRecord = (input, errorFactory) => {
     const __is = input => {
         const $io0 = input => (undefined === input.username || "string" === typeof input.username) && (undefined === input.roles || Array.isArray(input.roles) && input.roles.every(elem => "string" === typeof elem));
         return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
@@ -30,17 +30,17 @@ export const assertUserRecord = (input, errorFactory) => {
             }, errorFactory));
             return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
                 path: _path + "",
-                expected: "UserRecord",
+                expected: "UserDomainRecord",
                 value: input
             }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
                 path: _path + "",
-                expected: "UserRecord",
+                expected: "UserDomainRecord",
                 value: input
             }, errorFactory);
         })(input, "$input", true);
     return input;
 };
-export const randomUserRecord = generator => {
+export const randomUserDomainRecord = generator => {
     const $generator = __typia.createRandom.generator;
     const $pick = __typia.createRandom.pick;
     const $ro0 = (_recursive = false, _depth = 0) => ({
@@ -55,7 +55,7 @@ export const randomUserRecord = generator => {
     });
     return $ro0();
 };
-export const assertGuardUserRecord = (input, errorFactory) => {
+export const assertGuardUserDomainRecord = (input, errorFactory) => {
     const __is = input => {
         const $io0 = input => (undefined === input.username || "string" === typeof input.username) && (undefined === input.roles || Array.isArray(input.roles) && input.roles.every(elem => "string" === typeof elem));
         return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
@@ -82,22 +82,22 @@ export const assertGuardUserRecord = (input, errorFactory) => {
             }, errorFactory));
             return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
                 path: _path + "",
-                expected: "UserRecord",
+                expected: "UserDomainRecord",
                 value: input
             }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
                 path: _path + "",
-                expected: "UserRecord",
+                expected: "UserDomainRecord",
                 value: input
             }, errorFactory);
         })(input, "$input", true);
 };
-export const stringifyUserRecord = input => {
+export const stringifyUserDomainRecord = input => {
     const $string = __typia.json.createStringify.string;
     const $tail = __typia.json.createStringify.tail;
     const $so0 = input => `{${$tail(`${undefined === input.username ? "" : `"username":${undefined !== input.username ? $string(input.username) : undefined},`}${undefined === input.roles ? "" : `"roles":${undefined !== input.roles ? `[${input.roles.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
     return $so0(input);
 };
-export const assertStringifyUserRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+export const assertStringifyUserDomainRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
     const __is = input => {
         const $io0 = input => (undefined === input.username || "string" === typeof input.username) && (undefined === input.roles || Array.isArray(input.roles) && input.roles.every(elem => "string" === typeof elem));
         return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
@@ -124,11 +124,11 @@ export const assertStringifyUserRecord = (input, errorFactory) => { const assert
             }, errorFactory));
             return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
                 path: _path + "",
-                expected: "UserRecord",
+                expected: "UserDomainRecord",
                 value: input
             }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
                 path: _path + "",
-                expected: "UserRecord",
+                expected: "UserDomainRecord",
                 value: input
             }, errorFactory);
         })(input, "$input", true);
@@ -139,3 +139,343 @@ export const assertStringifyUserRecord = (input, errorFactory) => { const assert
     const $so0 = input => `{${$tail(`${undefined === input.username ? "" : `"username":${undefined !== input.username ? $string(input.username) : undefined},`}${undefined === input.roles ? "" : `"roles":${undefined !== input.roles ? `[${input.roles.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
     return $so0(input);
 }; return stringify(assert(input, errorFactory)); };
+export const isUserDomainLatestSeenNotificationRecord = input => {
+    const $io0 = input => undefined === input.value || "string" === typeof input.value;
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertUserDomainLatestSeenNotificationRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || "string" === typeof input.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 $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(string | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainLatestSeenNotificationRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainLatestSeenNotificationRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomUserDomainLatestSeenNotificationRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardUserDomainLatestSeenNotificationRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || "string" === typeof input.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 $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(string | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainLatestSeenNotificationRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainLatestSeenNotificationRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyUserDomainLatestSeenNotificationRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.value ? "" : `"value":${undefined !== input.value ? $string(input.value) : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyUserDomainLatestSeenNotificationRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || "string" === typeof input.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 $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(string | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainLatestSeenNotificationRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainLatestSeenNotificationRecord",
+                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 ? $string(input.value) : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isUserDomainReceivedNotificationsProvidedRecord = 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 assertUserDomainReceivedNotificationsProvidedRecord = (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: "UserDomainReceivedNotificationsProvidedRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainReceivedNotificationsProvidedRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomUserDomainReceivedNotificationsProvidedRecord = 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 assertGuardUserDomainReceivedNotificationsProvidedRecord = (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: "UserDomainReceivedNotificationsProvidedRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainReceivedNotificationsProvidedRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyUserDomainReceivedNotificationsProvidedRecord = 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 assertStringifyUserDomainReceivedNotificationsProvidedRecord = (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: "UserDomainReceivedNotificationsProvidedRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainReceivedNotificationsProvidedRecord",
+                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 isUserDomainUnseenNotificationsRecord = input => {
+    const $io0 = input => (undefined === input.hasUnseen || "boolean" === typeof input.hasUnseen) && (undefined === input.latestReceived || "string" === typeof input.latestReceived);
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertUserDomainUnseenNotificationsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.hasUnseen || "boolean" === typeof input.hasUnseen) && (undefined === input.latestReceived || "string" === typeof input.latestReceived);
+        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.hasUnseen || "boolean" === typeof input.hasUnseen || $guard(_exceptionable, {
+                path: _path + ".hasUnseen",
+                expected: "(boolean | undefined)",
+                value: input.hasUnseen
+            }, errorFactory)) && (undefined === input.latestReceived || "string" === typeof input.latestReceived || $guard(_exceptionable, {
+                path: _path + ".latestReceived",
+                expected: "(string | undefined)",
+                value: input.latestReceived
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainUnseenNotificationsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainUnseenNotificationsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomUserDomainUnseenNotificationsRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        hasUnseen: $pick([
+            () => undefined,
+            () => (generator?.boolean ?? $generator.boolean)()
+        ])(),
+        latestReceived: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardUserDomainUnseenNotificationsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.hasUnseen || "boolean" === typeof input.hasUnseen) && (undefined === input.latestReceived || "string" === typeof input.latestReceived);
+        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.hasUnseen || "boolean" === typeof input.hasUnseen || $guard(_exceptionable, {
+                path: _path + ".hasUnseen",
+                expected: "(boolean | undefined)",
+                value: input.hasUnseen
+            }, errorFactory)) && (undefined === input.latestReceived || "string" === typeof input.latestReceived || $guard(_exceptionable, {
+                path: _path + ".latestReceived",
+                expected: "(string | undefined)",
+                value: input.latestReceived
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainUnseenNotificationsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainUnseenNotificationsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyUserDomainUnseenNotificationsRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.hasUnseen ? "" : `"hasUnseen":${undefined !== input.hasUnseen ? input.hasUnseen : undefined},`}${undefined === input.latestReceived ? "" : `"latestReceived":${undefined !== input.latestReceived ? $string(input.latestReceived) : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyUserDomainUnseenNotificationsRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.hasUnseen || "boolean" === typeof input.hasUnseen) && (undefined === input.latestReceived || "string" === typeof input.latestReceived);
+        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.hasUnseen || "boolean" === typeof input.hasUnseen || $guard(_exceptionable, {
+                path: _path + ".hasUnseen",
+                expected: "(boolean | undefined)",
+                value: input.hasUnseen
+            }, errorFactory)) && (undefined === input.latestReceived || "string" === typeof input.latestReceived || $guard(_exceptionable, {
+                path: _path + ".latestReceived",
+                expected: "(string | undefined)",
+                value: input.latestReceived
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainUnseenNotificationsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "UserDomainUnseenNotificationsRecord",
+                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.hasUnseen ? "" : `"hasUnseen":${undefined !== input.hasUnseen ? input.hasUnseen : undefined},`}${undefined === input.latestReceived ? "" : `"latestReceived":${undefined !== input.latestReceived ? $string(input.latestReceived) : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/index.d.ts

@@ -43,7 +43,29 @@ export type Records = {
         };
         pick: string[];
     };
-} & AssetRecords;
+} & AssetRecords & {
+    "asset-daemon": {
+        "user-notify"?: boolean;
+    };
+    "asset-daemon:user-notify.state": {
+        since?: string | 0 | null;
+        version?: number;
+        error?: object | null;
+        status?: string | null;
+    };
+    "deepstream-replicator.stats?": {
+        replicators?: Record<string, {
+            to: {
+                synced?: boolean;
+                since?: string | 0 | null;
+            };
+            from: {
+                since?: string | 0 | null;
+            };
+        }>;
+        synced?: boolean;
+    };
+};
 interface DomainRows {
     rows: string[];
 }