@nxtedition/types 1.0.0

package/dist/common/index.js

@@ -0,0 +1,565 @@
+import __typia from "typia";
+export * from './block.js';
+export * from './lock.js';
+export * from './settings.js';
+export const isMessage = input => {
+    return "object" === typeof input && null !== input && ("number" === typeof input.level && "string" === typeof input.code && "string" === typeof input.msg);
+};
+export const assertMessage = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("number" === typeof input.level && "string" === typeof input.code && "string" === typeof input.msg);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.level || $guard(_exceptionable, {
+                path: _path + ".level",
+                expected: "number",
+                value: input.level
+            }, errorFactory)) && ("string" === typeof input.code || $guard(_exceptionable, {
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }, errorFactory)) && ("string" === typeof input.msg || $guard(_exceptionable, {
+                path: _path + ".msg",
+                expected: "string",
+                value: input.msg
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "Message",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "Message",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomMessage = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        level: (generator?.customs ?? $generator.customs)?.number?.([]) ?? (generator?.number ?? $generator.number)(0, 100),
+        code: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        msg: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+    });
+    return $ro0();
+};
+export const assertGuardMessage = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("number" === typeof input.level && "string" === typeof input.code && "string" === typeof input.msg);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.level || $guard(_exceptionable, {
+                path: _path + ".level",
+                expected: "number",
+                value: input.level
+            }, errorFactory)) && ("string" === typeof input.code || $guard(_exceptionable, {
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }, errorFactory)) && ("string" === typeof input.msg || $guard(_exceptionable, {
+                path: _path + ".msg",
+                expected: "string",
+                value: input.msg
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "Message",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "Message",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyMessage = input => {
+    const $string = __typia.json.createStringify.string;
+    return `{"level":${input.level},"code":${$string(input.code)},"msg":${$string(input.msg)}}`;
+};
+export const assertStringifyMessage = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        return "object" === typeof input && null !== input && ("number" === typeof input.level && !Number.isNaN(input.level) && "string" === typeof input.code && "string" === typeof input.msg);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.level && !Number.isNaN(input.level) || $guard(_exceptionable, {
+                path: _path + ".level",
+                expected: "number",
+                value: input.level
+            }, errorFactory)) && ("string" === typeof input.code || $guard(_exceptionable, {
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }, errorFactory)) && ("string" === typeof input.msg || $guard(_exceptionable, {
+                path: _path + ".msg",
+                expected: "string",
+                value: input.msg
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "Message",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "Message",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    return `{"level":${input.level},"code":${$string(input.code)},"msg":${$string(input.msg)}}`;
+}; return stringify(assert(input, errorFactory)); };
+export const isRpcMethods = input => {
+    const $io0 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && $io1(value);
+    });
+    const $io1 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io2(input.rpcData));
+    const $io2 = 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 assertRpcMethods = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && $io1(value);
+        });
+        const $io1 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io2(input.rpcData));
+        const $io2 = 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 ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "RpcMethod",
+                    value: value
+                }, errorFactory)) && $ao1(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "RpcMethod",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.rpcId || $guard(_exceptionable, {
+                path: _path + ".rpcId",
+                expected: "string",
+                value: input.rpcId
+            }, errorFactory)) && (("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory)) && $ao2(input.rpcData, _path + ".rpcData", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory));
+            const $ao2 = (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: "RpcMethods",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethods",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomRpcMethods = 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)()] = $ro1(_recursive, _recursive ? 1 + _depth : _depth), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    const $ro1 = (_recursive = false, _depth = 0) => ({
+        rpcId: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        rpcData: $ro2(_recursive, _recursive ? 1 + _depth : _depth)
+    });
+    const $ro2 = (_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 assertGuardRpcMethods = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && $io1(value);
+        });
+        const $io1 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io2(input.rpcData));
+        const $io2 = 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 ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "RpcMethod",
+                    value: value
+                }, errorFactory)) && $ao1(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "RpcMethod",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.rpcId || $guard(_exceptionable, {
+                path: _path + ".rpcId",
+                expected: "string",
+                value: input.rpcId
+            }, errorFactory)) && (("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory)) && $ao2(input.rpcData, _path + ".rpcData", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory));
+            const $ao2 = (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: "RpcMethods",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethods",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyRpcMethods = input => {
+    const $io1 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io2(input.rpcData));
+    const $io2 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$so1(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    const $so1 = input => `{"rpcId":${$string(input.rpcId)},"rpcData":${$so2(input.rpcData)}}`;
+    const $so2 = 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 assertStringifyRpcMethods = (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 "object" === typeof value && null !== value && $io1(value);
+        });
+        const $io1 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io2(input.rpcData));
+        const $io2 = 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 ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "RpcMethod",
+                    value: value
+                }, errorFactory)) && $ao1(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "RpcMethod",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.rpcId || $guard(_exceptionable, {
+                path: _path + ".rpcId",
+                expected: "string",
+                value: input.rpcId
+            }, errorFactory)) && (("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory)) && $ao2(input.rpcData, _path + ".rpcData", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory));
+            const $ao2 = (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: "RpcMethods",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethods",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io2(input.rpcData));
+    const $io2 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$so1(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    const $so1 = input => `{"rpcId":${$string(input.rpcId)},"rpcData":${$so2(input.rpcData)}}`;
+    const $so2 = 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)); };
+export const isRpcMethod = input => {
+    const $io0 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io1(input.rpcData));
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertRpcMethod = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io1(input.rpcData));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return true;
+        });
+        return "object" === typeof input && null !== 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) => ("string" === typeof input.rpcId || $guard(_exceptionable, {
+                path: _path + ".rpcId",
+                expected: "string",
+                value: input.rpcId
+            }, errorFactory)) && (("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory)) && $ao1(input.rpcData, _path + ".rpcData", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory));
+            const $ao1 = (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 || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethod",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethod",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomRpcMethod = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        rpcId: (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(),
+        rpcData: $ro1(_recursive, _recursive ? 1 + _depth : _depth)
+    });
+    const $ro1 = (_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 assertGuardRpcMethod = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io1(input.rpcData));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return true;
+        });
+        return "object" === typeof input && null !== 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) => ("string" === typeof input.rpcId || $guard(_exceptionable, {
+                path: _path + ".rpcId",
+                expected: "string",
+                value: input.rpcId
+            }, errorFactory)) && (("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory)) && $ao1(input.rpcData, _path + ".rpcData", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory));
+            const $ao1 = (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 || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethod",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethod",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyRpcMethod = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{"rpcId":${$string(input.rpcId)},"rpcData":${$so1(input.rpcData)}}`;
+    const $so1 = 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 assertStringifyRpcMethod = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => "string" === typeof input.rpcId && ("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) && $io1(input.rpcData));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return true;
+        });
+        return "object" === typeof input && null !== 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) => ("string" === typeof input.rpcId || $guard(_exceptionable, {
+                path: _path + ".rpcId",
+                expected: "string",
+                value: input.rpcId
+            }, errorFactory)) && (("object" === typeof input.rpcData && null !== input.rpcData && false === Array.isArray(input.rpcData) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory)) && $ao1(input.rpcData, _path + ".rpcData", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".rpcData",
+                expected: "Record<string, unknown>",
+                value: input.rpcData
+            }, errorFactory));
+            const $ao1 = (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 || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethod",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "RpcMethod",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return true;
+    });
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{"rpcId":${$string(input.rpcId)},"rpcData":${$so1(input.rpcData)}}`;
+    const $so1 = 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/common/lock.d.ts

@@ -0,0 +1,12 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface Lock {
+    time: number;
+    locations: string[] | null;
+    replicas: number | null;
+}
+export declare const isLock: (input: unknown) => input is Lock;
+export declare const assertLock: (input: unknown) => Lock;
+export declare const randomLock: () => Lock;
+export declare const assertGuardLock: __AssertionGuard<Lock>;
+export declare const stringifyLock: (input: Lock) => string;
+export declare const assertStringifyLock: (input: unknown) => string;