@nxtedition/types 1.2.8 → 1.4.0

package/dist/domains/asset.d.ts

@@ -2,6 +2,7 @@ import { type AssertionGuard as __AssertionGuard } from "typia";
 export interface AssetDomainRecords {
     ":asset.title?": AssetTitleRecord;
     ":asset.types?": AssetTypesRecord;
+    ":asset.assignees?": AssetAssigneesRecord;
 }
 export interface AssetTitleRecord {
     value?: string;
@@ -21,3 +22,12 @@ 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;

package/dist/domains/asset.js

@@ -223,3 +223,127 @@ 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)); };

package/dist/domains/connection.d.ts

@@ -7,7 +7,22 @@ export interface ConnectionDomainRecords {
 export type ConnectionRecord = FilePublishConnectionRecord | ReutersConnectionRecord | FacebookConnectionRecord;
 export declare const isConnectionRecord: (input: unknown) => input is ConnectionRecord;
 export declare const assertConnectionRecord: (input: unknown) => ConnectionRecord;
-export declare const randomConnectionRecord: () => ConnectionRecord;
+export declare const randomConnectionRecord: () => {
+    type: "file";
+    protocol: string;
+    host?: string | undefined;
+    port?: number | undefined;
+    ignoreMissing?: boolean | undefined;
+    concurrency?: number | undefined;
+} | {
+    type: "reuters";
+    clientId?: string | undefined;
+    clientSecret?: string | undefined;
+    audience?: string | undefined;
+} | {
+    type: "facebook";
+    grantedScopes?: string[] | undefined;
+};
 export declare const assertGuardConnectionRecord: __AssertionGuard<ConnectionRecord>;
 export declare const stringifyConnectionRecord: (input: ConnectionRecord) => string;
 export declare const assertStringifyConnectionRecord: (input: unknown) => string;

package/dist/domains/index.d.ts

@@ -4,6 +4,7 @@ import type { EventDomainRecords } from './event.js';
 import type { GeneralDomainRecords } from './general.js';
 import type { MediaDomainRecords } from './media.js';
 import type { PermissionDomainRecords } from './permission.js';
+import type { PlanningDomainRecords } from './planning.js';
 import type { PublishDomainRecords } from './publish.js';
 import type { RoleDomainRecords } from './role.js';
 import type { ScriptDomainRecords } from './script.js';
@@ -16,10 +17,11 @@ export * from './event.js';
 export * from './general.js';
 export * from './media.js';
 export * from './permission.js';
+export * from './planning.js';
 export * from './publish.js';
 export * from './role.js';
 export * from './script.js';
 export * from './search.js';
 export * from './settings.js';
 export * from './template.js';
-export type DomainRecords = AssetDomainRecords & ConnectionDomainRecords & EventDomainRecords & GeneralDomainRecords & MediaDomainRecords & PermissionDomainRecords & PublishDomainRecords & RoleDomainRecords & ScriptDomainRecords & SearchDomainRecords & SettingsDomainRecords & TemplateDomainRecords;
+export type DomainRecords = AssetDomainRecords & ConnectionDomainRecords & EventDomainRecords & GeneralDomainRecords & MediaDomainRecords & PermissionDomainRecords & PlanningDomainRecords & PublishDomainRecords & RoleDomainRecords & ScriptDomainRecords & SearchDomainRecords & SettingsDomainRecords & TemplateDomainRecords;

package/dist/domains/index.js

@@ -4,6 +4,7 @@ export * from './event.js';
 export * from './general.js';
 export * from './media.js';
 export * from './permission.js';
+export * from './planning.js';
 export * from './publish.js';
 export * from './role.js';
 export * from './script.js';

package/dist/domains/planning.d.ts

@@ -0,0 +1,33 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface PlanningDomainRecords {
+    ":planning": PlanningRecord;
+    ":planning.assignees": PlanningAssigneesRecord;
+    ":planning.deadline": PlanningDeadlineRecord;
+}
+export interface PlanningRecord {
+    deadline?: string | null;
+}
+export declare const isPlanningRecord: (input: unknown) => input is PlanningRecord;
+export declare const assertPlanningRecord: (input: unknown) => PlanningRecord;
+export declare const randomPlanningRecord: () => PlanningRecord;
+export declare const assertGuardPlanningRecord: __AssertionGuard<PlanningRecord>;
+export declare const stringifyPlanningRecord: (input: PlanningRecord) => string;
+export declare const assertStringifyPlanningRecord: (input: unknown) => string;
+export interface PlanningAssigneesRecord {
+    value: string[];
+}
+export declare const isPlanningAssigneesRecord: (input: unknown) => input is PlanningAssigneesRecord;
+export declare const assertPlanningAssigneesRecord: (input: unknown) => PlanningAssigneesRecord;
+export declare const randomPlanningAssigneesRecord: () => PlanningAssigneesRecord;
+export declare const assertGuardPlanningAssigneesRecord: __AssertionGuard<PlanningAssigneesRecord>;
+export declare const stringifyPlanningAssigneesRecord: (input: PlanningAssigneesRecord) => string;
+export declare const assertStringifyPlanningAssigneesRecord: (input: unknown) => string;
+export interface PlanningDeadlineRecord {
+    value: string | null;
+}
+export declare const isPlanningDeadlineRecord: (input: unknown) => input is PlanningDeadlineRecord;
+export declare const assertPlanningDeadlineRecord: (input: unknown) => PlanningDeadlineRecord;
+export declare const randomPlanningDeadlineRecord: () => PlanningDeadlineRecord;
+export declare const assertGuardPlanningDeadlineRecord: __AssertionGuard<PlanningDeadlineRecord>;
+export declare const stringifyPlanningDeadlineRecord: (input: PlanningDeadlineRecord) => string;
+export declare const assertStringifyPlanningDeadlineRecord: (input: unknown) => string;

package/dist/domains/planning.js

@@ -0,0 +1,318 @@
+import __typia from "typia";
+export const isPlanningRecord = input => {
+    const $io0 = input => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline;
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertPlanningRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline;
+        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) => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline || $guard(_exceptionable, {
+                path: _path + ".deadline",
+                expected: "(null | string | undefined)",
+                value: input.deadline
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPlanningRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        deadline: $pick([
+            () => undefined,
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardPlanningRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline;
+        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) => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline || $guard(_exceptionable, {
+                path: _path + ".deadline",
+                expected: "(null | string | undefined)",
+                value: input.deadline
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPlanningRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.deadline ? "" : `"deadline":${undefined !== input.deadline ? null !== input.deadline ? $string(input.deadline) : "null" : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyPlanningRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline;
+        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) => null === input.deadline || undefined === input.deadline || "string" === typeof input.deadline || $guard(_exceptionable, {
+                path: _path + ".deadline",
+                expected: "(null | string | undefined)",
+                value: input.deadline
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningRecord",
+                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.deadline ? "" : `"deadline":${undefined !== input.deadline ? null !== input.deadline ? $string(input.deadline) : "null" : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isPlanningAssigneesRecord = input => {
+    const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertPlanningAssigneesRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                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>",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PlanningAssigneesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningAssigneesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPlanningAssigneesRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+    });
+    return $ro0();
+};
+export const assertGuardPlanningAssigneesRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                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>",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PlanningAssigneesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningAssigneesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPlanningAssigneesRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{"value":${`[${input.value.map(elem => $string(elem)).join(",")}]`}}`;
+    return $so0(input);
+};
+export const assertStringifyPlanningAssigneesRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.value) || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "Array<string>",
+                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>",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PlanningAssigneesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningAssigneesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{"value":${`[${input.value.map(elem => $string(elem)).join(",")}]`}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isPlanningDeadlineRecord = input => {
+    const $io0 = input => null === input.value || "string" === typeof input.value;
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertPlanningDeadlineRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => null === input.value || "string" === typeof input.value;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => null === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(null | string)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PlanningDeadlineRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningDeadlineRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPlanningDeadlineRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardPlanningDeadlineRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => null === input.value || "string" === typeof input.value;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => null === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(null | string)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PlanningDeadlineRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningDeadlineRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPlanningDeadlineRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{"value":${null !== input.value ? $string(input.value) : "null"}}`;
+    return $so0(input);
+};
+export const assertStringifyPlanningDeadlineRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => null === input.value || "string" === typeof input.value;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => null === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(null | string)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PlanningDeadlineRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PlanningDeadlineRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{"value":${null !== input.value ? $string(input.value) : "null"}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };