@nxtedition/types 23.0.12 → 23.0.14

package/dist/domains/subtitle-style.d.ts

@@ -0,0 +1,13 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface SubtitleStyleDomainRecords {
+    ":subtitle-style": SubtitleStyleDomainRecord;
+}
+export interface SubtitleStyleDomainRecord {
+    [key: string]: unknown;
+}
+export declare const isSubtitleStyleDomainRecord: (input: unknown) => input is SubtitleStyleDomainRecord;
+export declare const assertSubtitleStyleDomainRecord: (input: unknown) => SubtitleStyleDomainRecord;
+export declare const randomSubtitleStyleDomainRecord: () => SubtitleStyleDomainRecord;
+export declare const assertGuardSubtitleStyleDomainRecord: __AssertionGuard<SubtitleStyleDomainRecord>;
+export declare const stringifySubtitleStyleDomainRecord: (input: SubtitleStyleDomainRecord) => string;
+export declare const assertStringifySubtitleStyleDomainRecord: (input: unknown) => string;

package/dist/domains/subtitle-style.js

@@ -0,0 +1,123 @@
+import __typia from "typia";
+export const isSubtitleStyleDomainRecord = input => {
+    const $io0 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertSubtitleStyleDomainRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return true;
+        });
+        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 true;
+            });
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "SubtitleStyleDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "SubtitleStyleDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomSubtitleStyleDomainRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => {
+        const output = {};
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()] = "any type used...", (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    return $ro0();
+};
+export const assertGuardSubtitleStyleDomainRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return true;
+        });
+        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 true;
+            });
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "SubtitleStyleDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "SubtitleStyleDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifySubtitleStyleDomainRecord = input => {
+    const $so0 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${undefined !== value ? JSON.stringify(value) : undefined}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+};
+export const assertStringifySubtitleStyleDomainRecord = (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 true;
+        });
+        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 true;
+            });
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "SubtitleStyleDomainRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "SubtitleStyleDomainRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $so0 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${undefined !== value ? JSON.stringify(value) : undefined}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/user-notification-status.d.ts

@@ -0,0 +1,55 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface UserNotificationStatusDomainRecords {
+    ":user-notification-status": UserNotificationStatusDomainRecord;
+}
+export interface UserNotificationStatusDomainRecord {
+    assignee?: UserNotificationStatusAssignee;
+    published?: UserNotificationStatusPublished;
+    comment?: UserNotificationStatusComment;
+}
+export declare const isUserNotificationStatusDomainRecord: (input: unknown) => input is UserNotificationStatusDomainRecord;
+export declare const assertUserNotificationStatusDomainRecord: (input: unknown) => UserNotificationStatusDomainRecord;
+export declare const randomUserNotificationStatusDomainRecord: () => UserNotificationStatusDomainRecord;
+export declare const assertGuardUserNotificationStatusDomainRecord: __AssertionGuard<UserNotificationStatusDomainRecord>;
+export declare const stringifyUserNotificationStatusDomainRecord: (input: UserNotificationStatusDomainRecord) => string;
+export declare const assertStringifyUserNotificationStatusDomainRecord: (input: unknown) => string;
+export interface UserNotificationStatusAssignee {
+    /**
+     * Array of user ID:s that was assigned to the assed last time it was
+     * considered for notifications.
+     */
+    value?: string[];
+}
+export declare const isUserNotificationStatusAssignee: (input: unknown) => input is UserNotificationStatusAssignee;
+export declare const assertUserNotificationStatusAssignee: (input: unknown) => UserNotificationStatusAssignee;
+export declare const randomUserNotificationStatusAssignee: () => UserNotificationStatusAssignee;
+export declare const assertGuardUserNotificationStatusAssignee: __AssertionGuard<UserNotificationStatusAssignee>;
+export declare const stringifyUserNotificationStatusAssignee: (input: UserNotificationStatusAssignee) => string;
+export declare const assertStringifyUserNotificationStatusAssignee: (input: unknown) => string;
+export interface UserNotificationStatusComment {
+    /**
+     * When array of user ID:s: Indicates which users have been considered for
+     * notifications about this comment. When `true`: Indicates that we have
+     * considered this comment for notifications, but we don't know which users
+     * have been notified.
+     */
+    value?: string[] | true;
+}
+export declare const isUserNotificationStatusComment: (input: unknown) => input is UserNotificationStatusComment;
+export declare const assertUserNotificationStatusComment: (input: unknown) => UserNotificationStatusComment;
+export declare const randomUserNotificationStatusComment: () => UserNotificationStatusComment;
+export declare const assertGuardUserNotificationStatusComment: __AssertionGuard<UserNotificationStatusComment>;
+export declare const stringifyUserNotificationStatusComment: (input: UserNotificationStatusComment) => string;
+export declare const assertStringifyUserNotificationStatusComment: (input: unknown) => string;
+export interface UserNotificationStatusPublished {
+    /**
+     * If `true`, this published asset has been considered for notifications.
+     */
+    value?: true;
+}
+export declare const isUserNotificationStatusPublished: (input: unknown) => input is UserNotificationStatusPublished;
+export declare const assertUserNotificationStatusPublished: (input: unknown) => UserNotificationStatusPublished;
+export declare const randomUserNotificationStatusPublished: () => UserNotificationStatusPublished;
+export declare const assertGuardUserNotificationStatusPublished: __AssertionGuard<UserNotificationStatusPublished>;
+export declare const stringifyUserNotificationStatusPublished: (input: UserNotificationStatusPublished) => string;
+export declare const assertStringifyUserNotificationStatusPublished: (input: unknown) => string;