@nxtedition/types 1.3.0 → 1.5.0

package/dist/domains/asset.d.ts

@@ -2,6 +2,8 @@ import { type AssertionGuard as __AssertionGuard } from "typia";
 export interface AssetDomainRecords {
     ":asset.title?": AssetTitleRecord;
     ":asset.types?": AssetTypesRecord;
+    ":asset.assignees?": AssetAssigneesRecord;
+    ":asset.refs?": AssetRefsRecord;
 }
 export interface AssetTitleRecord {
     value?: string;
@@ -21,3 +23,27 @@ export declare const randomAssetTypesRecord: () => AssetTypesRecord;
 export declare const assertGuardAssetTypesRecord: __AssertionGuard<AssetTypesRecord>;
 export declare const stringifyAssetTypesRecord: (input: AssetTypesRecord) => string;
 export declare const assertStringifyAssetTypesRecord: (input: unknown) => string;
+export interface AssetAssigneesRecord {
+    value?: string[];
+}
+export declare const isAssetAssigneesRecord: (input: unknown) => input is AssetAssigneesRecord;
+export declare const assertAssetAssigneesRecord: (input: unknown) => AssetAssigneesRecord;
+export declare const randomAssetAssigneesRecord: () => AssetAssigneesRecord;
+export declare const assertGuardAssetAssigneesRecord: __AssertionGuard<AssetAssigneesRecord>;
+export declare const stringifyAssetAssigneesRecord: (input: AssetAssigneesRecord) => string;
+export declare const assertStringifyAssetAssigneesRecord: (input: unknown) => string;
+export interface AssetRefsRecord {
+    value?: AssetRef[];
+}
+export declare const isAssetRefsRecord: (input: unknown) => input is AssetRefsRecord;
+export declare const assertAssetRefsRecord: (input: unknown) => AssetRefsRecord;
+export declare const randomAssetRefsRecord: () => AssetRefsRecord;
+export declare const assertGuardAssetRefsRecord: __AssertionGuard<AssetRefsRecord>;
+export declare const stringifyAssetRefsRecord: (input: AssetRefsRecord) => string;
+export declare const assertStringifyAssetRefsRecord: (input: unknown) => string;
+interface AssetRef {
+    id: string;
+    key: string;
+    value: string;
+}
+export {};

package/dist/domains/asset.js

@@ -223,3 +223,313 @@ export const assertStringifyAssetTypesRecord = (input, errorFactory) => { const
     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 isAssetAssigneesRecord = 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 assertAssetAssigneesRecord = (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: "AssetAssigneesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetAssigneesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomAssetAssigneesRecord = 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 assertGuardAssetAssigneesRecord = (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: "AssetAssigneesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetAssigneesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyAssetAssigneesRecord = 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 assertStringifyAssetAssigneesRecord = (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: "AssetAssigneesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetAssigneesRecord",
+                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 isAssetRefsRecord = input => {
+    const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "object" === typeof elem && null !== elem && $io1(elem));
+    const $io1 = input => "string" === typeof input.id && "string" === typeof input.key && "string" === typeof input.value;
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertAssetRefsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "object" === typeof elem && null !== elem && $io1(elem));
+        const $io1 = input => "string" === typeof input.id && "string" === typeof input.key && "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 || (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<AssetRef> | undefined)",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => ("object" === typeof elem && null !== elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "AssetRef",
+                value: elem
+            }, errorFactory)) && $ao1(elem, _path + ".value[" + _index1 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "AssetRef",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<AssetRef> | undefined)",
+                value: input.value
+            }, errorFactory);
+            const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || $guard(_exceptionable, {
+                path: _path + ".id",
+                expected: "string",
+                value: input.id
+            }, errorFactory)) && ("string" === typeof input.key || $guard(_exceptionable, {
+                path: _path + ".key",
+                expected: "string",
+                value: input.key
+            }, errorFactory)) && ("string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "string",
+                value: input.value
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "AssetRefsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetRefsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomAssetRefsRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: $pick([
+            () => undefined,
+            () => (generator?.array ?? $generator.array)(() => $ro1(_recursive, _recursive ? 1 + _depth : _depth))
+        ])()
+    });
+    const $ro1 = (_recursive = false, _depth = 0) => ({
+        id: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        key: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        value: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+    });
+    return $ro0();
+};
+export const assertGuardAssetRefsRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "object" === typeof elem && null !== elem && $io1(elem));
+        const $io1 = input => "string" === typeof input.id && "string" === typeof input.key && "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 || (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<AssetRef> | undefined)",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => ("object" === typeof elem && null !== elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "AssetRef",
+                value: elem
+            }, errorFactory)) && $ao1(elem, _path + ".value[" + _index1 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "AssetRef",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<AssetRef> | undefined)",
+                value: input.value
+            }, errorFactory);
+            const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || $guard(_exceptionable, {
+                path: _path + ".id",
+                expected: "string",
+                value: input.id
+            }, errorFactory)) && ("string" === typeof input.key || $guard(_exceptionable, {
+                path: _path + ".key",
+                expected: "string",
+                value: input.key
+            }, errorFactory)) && ("string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "string",
+                value: input.value
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "AssetRefsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetRefsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyAssetRefsRecord = input => {
+    const $io1 = input => "string" === typeof input.id && "string" === typeof input.key && "string" === typeof input.value;
+    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 => `{"id":${$string(elem.id)},"key":${$string(elem.key)},"value":${$string(elem.value)}}`).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyAssetRefsRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || Array.isArray(input.value) && input.value.every(elem => "object" === typeof elem && null !== elem && $io1(elem));
+        const $io1 = input => "string" === typeof input.id && "string" === typeof input.key && "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 || (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<AssetRef> | undefined)",
+                value: input.value
+            }, errorFactory)) && input.value.every((elem, _index1) => ("object" === typeof elem && null !== elem || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "AssetRef",
+                value: elem
+            }, errorFactory)) && $ao1(elem, _path + ".value[" + _index1 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".value[" + _index1 + "]",
+                expected: "AssetRef",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(Array<AssetRef> | undefined)",
+                value: input.value
+            }, errorFactory);
+            const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || $guard(_exceptionable, {
+                path: _path + ".id",
+                expected: "string",
+                value: input.id
+            }, errorFactory)) && ("string" === typeof input.key || $guard(_exceptionable, {
+                path: _path + ".key",
+                expected: "string",
+                value: input.key
+            }, errorFactory)) && ("string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "string",
+                value: input.value
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "AssetRefsRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetRefsRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => "string" === typeof input.id && "string" === typeof input.key && "string" === typeof input.value;
+    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 => `{"id":${$string(elem.id)},"key":${$string(elem.key)},"value":${$string(elem.value)}}`).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/general.d.ts

@@ -2,6 +2,10 @@ import { type AssertionGuard as __AssertionGuard } from "typia";
 export interface GeneralDomainRecords {
     ":general.title": GeneralTitleRecord;
     ":general.tags": GeneralTagsRecord;
+    ":general.created": GeneralCreatedRecord;
+    ":general.poster": GeneralPosterRecord;
+    ":general.status": GeneralStatusRecord;
+    ":general.description": GeneralDescriptionRecord;
 }
 export interface GeneralTitleRecord {
     value?: string;
@@ -21,3 +25,54 @@ export declare const randomGeneralTagsRecord: () => GeneralTagsRecord;
 export declare const assertGuardGeneralTagsRecord: __AssertionGuard<GeneralTagsRecord>;
 export declare const stringifyGeneralTagsRecord: (input: GeneralTagsRecord) => string;
 export declare const assertStringifyGeneralTagsRecord: (input: unknown) => string;
+export interface GeneralCreatedRecord {
+    time?: string;
+    user?: string;
+    origin?: string;
+}
+export declare const isGeneralCreatedRecord: (input: unknown) => input is GeneralCreatedRecord;
+export declare const assertGeneralCreatedRecord: (input: unknown) => GeneralCreatedRecord;
+export declare const randomGeneralCreatedRecord: () => GeneralCreatedRecord;
+export declare const assertGuardGeneralCreatedRecord: __AssertionGuard<GeneralCreatedRecord>;
+export declare const stringifyGeneralCreatedRecord: (input: GeneralCreatedRecord) => string;
+export declare const assertStringifyGeneralCreatedRecord: (input: unknown) => string;
+export interface GeneralPosterRecord {
+    input?: {
+        type?: string;
+        file?: string;
+    };
+    preset?: string;
+}
+export declare const isGeneralPosterRecord: (input: unknown) => input is GeneralPosterRecord;
+export declare const assertGeneralPosterRecord: (input: unknown) => GeneralPosterRecord;
+export declare const randomGeneralPosterRecord: () => GeneralPosterRecord;
+export declare const assertGuardGeneralPosterRecord: __AssertionGuard<GeneralPosterRecord>;
+export declare const stringifyGeneralPosterRecord: (input: GeneralPosterRecord) => string;
+export declare const assertStringifyGeneralPosterRecord: (input: unknown) => string;
+export type GeneralStatusRecord = {
+    [messageId: string]: GeneralStatusRecordValue;
+};
+export declare const isGeneralStatusRecord: (input: unknown) => input is GeneralStatusRecord;
+export declare const assertGeneralStatusRecord: (input: unknown) => GeneralStatusRecord;
+export declare const randomGeneralStatusRecord: () => GeneralStatusRecord;
+export declare const assertGuardGeneralStatusRecord: __AssertionGuard<GeneralStatusRecord>;
+export declare const stringifyGeneralStatusRecord: (input: GeneralStatusRecord) => string;
+export declare const assertStringifyGeneralStatusRecord: (input: unknown) => string;
+export interface GeneralStatusRecordValue {
+    expose?: boolean;
+}
+export declare const isGeneralStatusRecordValue: (input: unknown) => input is GeneralStatusRecordValue;
+export declare const assertGeneralStatusRecordValue: (input: unknown) => GeneralStatusRecordValue;
+export declare const randomGeneralStatusRecordValue: () => GeneralStatusRecordValue;
+export declare const assertGuardGeneralStatusRecordValue: __AssertionGuard<GeneralStatusRecordValue>;
+export declare const stringifyGeneralStatusRecordValue: (input: GeneralStatusRecordValue) => string;
+export declare const assertStringifyGeneralStatusRecordValue: (input: unknown) => string;
+export interface GeneralDescriptionRecord {
+    value?: string;
+}
+export declare const isGeneralDescriptionRecord: (input: unknown) => input is GeneralDescriptionRecord;
+export declare const assertGeneralDescriptionRecord: (input: unknown) => GeneralDescriptionRecord;
+export declare const randomGeneralDescriptionRecord: () => GeneralDescriptionRecord;
+export declare const assertGuardGeneralDescriptionRecord: __AssertionGuard<GeneralDescriptionRecord>;
+export declare const stringifyGeneralDescriptionRecord: (input: GeneralDescriptionRecord) => string;
+export declare const assertStringifyGeneralDescriptionRecord: (input: unknown) => string;