@nosana/types 2.2.13 → 2.2.16

package/dist/Jobs/JobDefinition/args/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/args/index.ts"],"names":[],"mappings":"AAaA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/args/index.ts"],"names":[],"mappings":"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"}

package/dist/Jobs/JobDefinition/execution/index.d.ts

@@ -1,3 +1,4 @@
+import { type IValidation } from "typia";
 type GroupDependencies = {
     depends_on?: never;
     stop_if_dependent_stops?: never;
@@ -7,6 +8,8 @@ type GroupDependencies = {
 };
 export type Execution = {
     group?: string;
+    timeout?: number;
 } & GroupDependencies;
+export declare const validateExecution: (input: unknown) => IValidation<Execution>;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/Jobs/JobDefinition/execution/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/execution/index.ts"],"names":[],"mappings":"AAAA,KAAK,iBAAiB,GAAG;IACvB,UAAU,CAAC,EAAE,KAAK,CAAA;IAClB,uBAAuB,CAAC,EAAE,KAAK,CAAC;CACjC,GACG;IACA,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAGJ,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/execution/index.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AAEhD,KAAK,iBAAiB,GAAG;IACvB,UAAU,CAAC,EAAE,KAAK,CAAA;IAClB,uBAAuB,CAAC,EAAE,KAAK,CAAC;CACjC,GACG;IACA,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAGJ,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,iBAAiB,CAAA;AAErB,eAAO,MAAM,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,WAAW,CAAC,SAAS,CAChC,CAAC"}

package/dist/Jobs/JobDefinition/execution/index.js

@@ -1,2 +1,137 @@
-export {};
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema.js";
+import typia from "typia";
+export const validateExecution = (() => { const _io0 = (input, _exceptionable = true) => (undefined === input.group || "string" === typeof input.group) && (undefined === input.timeout || "number" === typeof input.timeout) && (null !== input.depends_on && undefined === input.depends_on) && (null !== input.stop_if_dependent_stops && undefined === input.stop_if_dependent_stops) && (0 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["group", "timeout", "depends_on", "stop_if_dependent_stops"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => (undefined === input.group || "string" === typeof input.group) && (undefined === input.timeout || "number" === typeof input.timeout) && (Array.isArray(input.depends_on) && input.depends_on.every((elem, _index1) => "string" === typeof elem)) && (undefined === input.stop_if_dependent_stops || "boolean" === typeof input.stop_if_dependent_stops) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["group", "timeout", "depends_on", "stop_if_dependent_stops"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if (Array.isArray(input.depends_on) && input.depends_on.every((elem, _index2) => "string" === typeof elem))
+        return _io1(input, true && _exceptionable);
+    else
+        return _io0(input, true && _exceptionable);
+})(); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.group || "string" === typeof input.group || _report(_exceptionable, {
+        path: _path + ".group",
+        expected: "(string | undefined)",
+        value: input.group
+    }), undefined === input.timeout || "number" === typeof input.timeout || _report(_exceptionable, {
+        path: _path + ".timeout",
+        expected: "(number | undefined)",
+        value: input.timeout
+    }), (null !== input.depends_on || _report(_exceptionable, {
+        path: _path + ".depends_on",
+        expected: "undefined",
+        value: input.depends_on
+    })) && (undefined === input.depends_on || _report(_exceptionable, {
+        path: _path + ".depends_on",
+        expected: "undefined",
+        value: input.depends_on
+    })), (null !== input.stop_if_dependent_stops || _report(_exceptionable, {
+        path: _path + ".stop_if_dependent_stops",
+        expected: "undefined",
+        value: input.stop_if_dependent_stops
+    })) && (undefined === input.stop_if_dependent_stops || _report(_exceptionable, {
+        path: _path + ".stop_if_dependent_stops",
+        expected: "undefined",
+        value: input.stop_if_dependent_stops
+    })), 0 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map(key => {
+        if (["group", "timeout", "depends_on", "stop_if_dependent_stops"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value,
+            description: [
+                `The property \`${key}\` is not defined in the object type.`,
+                "",
+                "Please remove the property next time."
+            ].join("\n")
+        });
+    }).every(flag => flag))].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [undefined === input.group || "string" === typeof input.group || _report(_exceptionable, {
+        path: _path + ".group",
+        expected: "(string | undefined)",
+        value: input.group
+    }), undefined === input.timeout || "number" === typeof input.timeout || _report(_exceptionable, {
+        path: _path + ".timeout",
+        expected: "(number | undefined)",
+        value: input.timeout
+    }), (Array.isArray(input.depends_on) || _report(_exceptionable, {
+        path: _path + ".depends_on",
+        expected: "Array<string>",
+        value: input.depends_on
+    })) && input.depends_on.map((elem, _index3) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".depends_on[" + _index3 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".depends_on",
+        expected: "Array<string>",
+        value: input.depends_on
+    }), undefined === input.stop_if_dependent_stops || "boolean" === typeof input.stop_if_dependent_stops || _report(_exceptionable, {
+        path: _path + ".stop_if_dependent_stops",
+        expected: "(boolean | undefined)",
+        value: input.stop_if_dependent_stops
+    }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map(key => {
+        if (["group", "timeout", "depends_on", "stop_if_dependent_stops"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value,
+            description: [
+                `The property \`${key}\` is not defined in the object type.`,
+                "",
+                "Please remove the property next time."
+            ].join("\n")
+        });
+    }).every(flag => flag))].every(flag => flag); const _vu0 = (input, _path, _exceptionable = true) => (() => {
+    if (Array.isArray(input.depends_on) && input.depends_on.map((elem, _index4) => "string" === typeof elem).every(flag => flag))
+        return _vo1(input, _path, true && _exceptionable);
+    else
+        return _vo0(input, _path, true && _exceptionable);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && false === Array.isArray(input) && _iu0(input, true); let errors; let _report; return __typia_transform__createStandardSchema._createStandardSchema(input => {
+    if (false === __is(input)) {
+        errors = [];
+        _report = __typia_transform__validateReport._validateReport(errors);
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
+            path: _path + "",
+            expected: "({ group?: string | undefined; timeout?: number | undefined; } & { depends_on: string[]; stop_if_dependent_stops?: boolean | undefined; } | { group?: string | undefined; timeout?: number | undefined; } & { depends_on?: undefined; stop_if_dependent_stops?: undefined; })",
+            value: input
+        })) && _vu0(input, _path + "", true) || _report(true, {
+            path: _path + "",
+            expected: "({ group?: string | undefined; timeout?: number | undefined; } & { depends_on: string[]; stop_if_dependent_stops?: boolean | undefined; } | { group?: string | undefined; timeout?: number | undefined; } & { depends_on?: undefined; stop_if_dependent_stops?: undefined; })",
+            value: input
+        }))(input, "$input", true);
+        const success = 0 === errors.length;
+        return success ? {
+            success,
+            data: input
+        } : {
+            success,
+            errors,
+            data: input
+        };
+    }
+    return {
+        success: true,
+        data: input
+    };
+}); })();
 //# sourceMappingURL=index.js.map

package/dist/Jobs/JobDefinition/execution/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/execution/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/execution/index.ts"],"names":[],"mappings":";;;AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAiBhD,MAAM,CAAC,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACW,CAAC"}

package/dist/Jobs/JobDefinition/global/index.d.ts

@@ -1,3 +1,4 @@
+import { type IValidation } from "typia";
 import type { CMDArray, CMDString, Env, GPU, Image, Variables, WorkDir } from "../args/index.js";
 export interface Global {
     image?: Image;
@@ -7,4 +8,5 @@ export interface Global {
     work_dir?: WorkDir;
     variables?: Variables;
 }
+export declare const validateGlobal: (input: unknown) => IValidation<Global>;
 //# sourceMappingURL=index.d.ts.map

package/dist/Jobs/JobDefinition/global/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/global/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEjG,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,UAAU,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IAClC,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/global/index.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEjG,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,UAAU,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IAClC,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB;AAED,eAAO,MAAM,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,WAAW,CAAC,MAAM,CAC7B,CAAC"}

package/dist/Jobs/JobDefinition/global/index.js

@@ -1,2 +1,128 @@
-export {};
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema.js";
+import typia from "typia";
+export const validateGlobal = (() => { const _io0 = (input, _exceptionable = true) => (undefined === input.image || "string" === typeof input.image) && (undefined === input.gpu || "boolean" === typeof input.gpu) && (null !== input.entrypoint && (undefined === input.entrypoint || "string" === typeof input.entrypoint || Array.isArray(input.entrypoint) && input.entrypoint.every((elem, _index1) => "string" === typeof elem))) && (undefined === input.env || "object" === typeof input.env && null !== input.env && false === Array.isArray(input.env) && _io1(input.env, true && _exceptionable)) && (undefined === input.work_dir || "string" === typeof input.work_dir) && (undefined === input.variables || "object" === typeof input.variables && null !== input.variables && false === Array.isArray(input.variables) && _io2(input.variables, true && _exceptionable)) && (0 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["image", "gpu", "entrypoint", "env", "work_dir", "variables"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "string" === typeof value;
+}); const _io2 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "string" === typeof value;
+}); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.image || "string" === typeof input.image || _report(_exceptionable, {
+        path: _path + ".image",
+        expected: "(string | undefined)",
+        value: input.image
+    }), undefined === input.gpu || "boolean" === typeof input.gpu || _report(_exceptionable, {
+        path: _path + ".gpu",
+        expected: "(boolean | undefined)",
+        value: input.gpu
+    }), (null !== input.entrypoint || _report(_exceptionable, {
+        path: _path + ".entrypoint",
+        expected: "(CMDArray | string | undefined)",
+        value: input.entrypoint
+    })) && (undefined === input.entrypoint || "string" === typeof input.entrypoint || (Array.isArray(input.entrypoint) || _report(_exceptionable, {
+        path: _path + ".entrypoint",
+        expected: "(CMDArray | string | undefined)",
+        value: input.entrypoint
+    })) && input.entrypoint.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
+        path: _path + ".entrypoint[" + _index2 + "]",
+        expected: "string",
+        value: elem
+    })).every(flag => flag) || _report(_exceptionable, {
+        path: _path + ".entrypoint",
+        expected: "(CMDArray | string | undefined)",
+        value: input.entrypoint
+    })), undefined === input.env || ("object" === typeof input.env && null !== input.env && false === Array.isArray(input.env) || _report(_exceptionable, {
+        path: _path + ".env",
+        expected: "(Env | undefined)",
+        value: input.env
+    })) && _vo1(input.env, _path + ".env", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".env",
+        expected: "(Env | undefined)",
+        value: input.env
+    }), undefined === input.work_dir || "string" === typeof input.work_dir || _report(_exceptionable, {
+        path: _path + ".work_dir",
+        expected: "(string | undefined)",
+        value: input.work_dir
+    }), undefined === input.variables || ("object" === typeof input.variables && null !== input.variables && false === Array.isArray(input.variables) || _report(_exceptionable, {
+        path: _path + ".variables",
+        expected: "(Variables | undefined)",
+        value: input.variables
+    })) && _vo2(input.variables, _path + ".variables", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".variables",
+        expected: "(Variables | undefined)",
+        value: input.variables
+    }), 0 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map(key => {
+        if (["image", "gpu", "entrypoint", "env", "work_dir", "variables"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value,
+            description: [
+                `The property \`${key}\` is not defined in the object type.`,
+                "",
+                "Please remove the property next time."
+            ].join("\n")
+        });
+    }).every(flag => flag))].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "string",
+            value: value
+        });
+    }).every(flag => flag)].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "string",
+            value: value
+        });
+    }).every(flag => flag)].every(flag => flag); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input, true); let errors; let _report; return __typia_transform__createStandardSchema._createStandardSchema(input => {
+    if (false === __is(input)) {
+        errors = [];
+        _report = __typia_transform__validateReport._validateReport(errors);
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
+            path: _path + "",
+            expected: "Global",
+            value: input
+        })) && _vo0(input, _path + "", true) || _report(true, {
+            path: _path + "",
+            expected: "Global",
+            value: input
+        }))(input, "$input", true);
+        const success = 0 === errors.length;
+        return success ? {
+            success,
+            data: input
+        } : {
+            success,
+            errors,
+            data: input
+        };
+    }
+    return {
+        success: true,
+        data: input
+    };
+}); })();
 //# sourceMappingURL=index.js.map

package/dist/Jobs/JobDefinition/global/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/global/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/global/index.ts"],"names":[],"mappings":";;;AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAYhD,MAAM,CAAC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACW,CAAC"}

package/dist/Jobs/JobDefinition/logistics/index.d.ts

@@ -1,3 +1,4 @@
+import { type IValidation } from "typia";
 /**
  * api        - we receive and send via an endpoint endpoint
  * api-listen - we create an endpoint to listen for incoming requests
@@ -18,5 +19,6 @@ export interface Logistics {
     send: Logistic;
     receive: Logistic;
 }
+export declare const validateLogistics: (input: unknown) => IValidation<Logistics>;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/Jobs/JobDefinition/logistics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/logistics/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,YAAY;;;CAGf,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAC1E,KAAK,YAAY,GAAG,OAAO,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC;CACnB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/logistics/index.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,YAAY;;;CAGf,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAC1E,KAAK,YAAY,GAAG,OAAO,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC;CACnB;AAED,eAAO,MAAM,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,WAAW,CAAC,SAAS,CAChC,CAAC"}

package/dist/Jobs/JobDefinition/logistics/index.js

@@ -1,3 +1,7 @@
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema.js";
+import typia from "typia";
 /**
  * api        - we receive and send via an endpoint endpoint
  * api-listen - we create an endpoint to listen for incoming requests
@@ -6,4 +10,133 @@ export const LogisticType = {
     API: 'api',
     API_LISTEN: 'api-listen',
 };
+export const validateLogistics = (() => { const _io0 = (input, _exceptionable = true) => "object" === typeof input.send && null !== input.send && _io1(input.send, true && _exceptionable) && ("object" === typeof input.receive && null !== input.receive && _io1(input.receive, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["send", "receive"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => ("api" === input.type || "api-listen" === input.type) && ("object" === typeof input.args && null !== input.args && false === Array.isArray(input.args) && _io2(input.args, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "args"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io2 = (input, _exceptionable = true) => (undefined === input.endpoint || "string" === typeof input.endpoint) && (0 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["endpoint"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.send && null !== input.send || _report(_exceptionable, {
+        path: _path + ".send",
+        expected: "Logistic",
+        value: input.send
+    })) && _vo1(input.send, _path + ".send", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".send",
+        expected: "Logistic",
+        value: input.send
+    }), ("object" === typeof input.receive && null !== input.receive || _report(_exceptionable, {
+        path: _path + ".receive",
+        expected: "Logistic",
+        value: input.receive
+    })) && _vo1(input.receive, _path + ".receive", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".receive",
+        expected: "Logistic",
+        value: input.receive
+    }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map(key => {
+        if (["send", "receive"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value,
+            description: [
+                `The property \`${key}\` is not defined in the object type.`,
+                "",
+                "Please remove the property next time."
+            ].join("\n")
+        });
+    }).every(flag => flag))].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["api" === input.type || "api-listen" === input.type || _report(_exceptionable, {
+        path: _path + ".type",
+        expected: "(\"api\" | \"api-listen\")",
+        value: input.type
+    }), ("object" === typeof input.args && null !== input.args && false === Array.isArray(input.args) || _report(_exceptionable, {
+        path: _path + ".args",
+        expected: "Partial<__type>",
+        value: input.args
+    })) && _vo2(input.args, _path + ".args", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".args",
+        expected: "Partial<__type>",
+        value: input.args
+    }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map(key => {
+        if (["type", "args"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value,
+            description: [
+                `The property \`${key}\` is not defined in the object type.`,
+                "",
+                "Please remove the property next time."
+            ].join("\n")
+        });
+    }).every(flag => flag))].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => [undefined === input.endpoint || "string" === typeof input.endpoint || _report(_exceptionable, {
+        path: _path + ".endpoint",
+        expected: "(string | undefined)",
+        value: input.endpoint
+    }), 0 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map(key => {
+        if (["endpoint"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value,
+            description: [
+                `The property \`${key}\` is not defined in the object type.`,
+                "",
+                "Please remove the property next time."
+            ].join("\n")
+        });
+    }).every(flag => flag))].every(flag => flag); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true); let errors; let _report; return __typia_transform__createStandardSchema._createStandardSchema(input => {
+    if (false === __is(input)) {
+        errors = [];
+        _report = __typia_transform__validateReport._validateReport(errors);
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+            path: _path + "",
+            expected: "Logistics",
+            value: input
+        })) && _vo0(input, _path + "", true) || _report(true, {
+            path: _path + "",
+            expected: "Logistics",
+            value: input
+        }))(input, "$input", true);
+        const success = 0 === errors.length;
+        return success ? {
+            success,
+            data: input
+        } : {
+            success,
+            errors,
+            data: input
+        };
+    }
+    return {
+        success: true,
+        data: input
+    };
+}); })();
 //# sourceMappingURL=index.js.map

package/dist/Jobs/JobDefinition/logistics/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/logistics/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,YAAY;CAChB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/logistics/index.ts"],"names":[],"mappings":";;;AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAEhD;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,YAAY;CAChB,CAAC;AAgBX,MAAM,CAAC,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACW,CAAC"}

package/dist/Jobs/JobDefinition/meta/index.d.ts

@@ -1,6 +1,8 @@
+import { type IValidation } from "typia";
 export type Meta = {
     trigger?: string;
     system_resources?: Record<string, string | number>;
     [key: string]: string | number | Record<string, string | number | Array<string | number>> | Array<string | number> | undefined;
 };
+export declare const validateMeta: (input: unknown) => IValidation<Meta>;
 //# sourceMappingURL=index.d.ts.map

package/dist/Jobs/JobDefinition/meta/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/meta/index.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,IAAI,GAAG;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACnD,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC;CAChI,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/meta/index.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AAEhD,MAAM,MAAM,IAAI,GAAG;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACnD,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC;CAChI,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,WAAW,CAAC,IAAI,CAC3B,CAAC"}

package/dist/Jobs/JobDefinition/meta/index.js

@@ -1,2 +1,119 @@
-export {};
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema.js";
+import typia from "typia";
+export const validateMeta = (() => { const _io0 = (input, _exceptionable = true) => (undefined === input.trigger || "string" === typeof input.trigger) && (undefined === input.system_resources || "object" === typeof input.system_resources && null !== input.system_resources && false === Array.isArray(input.system_resources) && _io1(input.system_resources, true && _exceptionable)) && Object.keys(input).every(key => {
+    if (["trigger", "system_resources"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return null !== value && (undefined === value || "string" === typeof value || "number" === typeof value || (Array.isArray(value) && value.every((elem, _index1) => "string" === typeof elem || "number" === typeof elem) || "object" === typeof value && null !== value && false === Array.isArray(value) && _io2(value, true && _exceptionable)));
+}); const _io1 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "string" === typeof value || "number" === typeof value;
+}); const _io2 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return null !== value && undefined !== value && ("string" === typeof value || "number" === typeof value || Array.isArray(value) && value.every((elem, _index2) => "string" === typeof elem || "number" === typeof elem));
+}); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.trigger || "string" === typeof input.trigger || _report(_exceptionable, {
+        path: _path + ".trigger",
+        expected: "(string | undefined)",
+        value: input.trigger
+    }), undefined === input.system_resources || ("object" === typeof input.system_resources && null !== input.system_resources && false === Array.isArray(input.system_resources) || _report(_exceptionable, {
+        path: _path + ".system_resources",
+        expected: "(Record<string, string | number> | undefined)",
+        value: input.system_resources
+    })) && _vo1(input.system_resources, _path + ".system_resources", true && _exceptionable) || _report(_exceptionable, {
+        path: _path + ".system_resources",
+        expected: "(Record<string, string | number> | undefined)",
+        value: input.system_resources
+    }), false === _exceptionable || Object.keys(input).map(key => {
+        if (["trigger", "system_resources"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return (null !== value || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | Record<string, string | number | (string | number)[]> | number | string | undefined)",
+            value: value
+        })) && (undefined === value || "string" === typeof value || "number" === typeof value || (Array.isArray(value) && value.map((elem, _index3) => "string" === typeof elem || "number" === typeof elem || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key) + "[" + _index3 + "]",
+            expected: "(number | string)",
+            value: elem
+        })).every(flag => flag) || "object" === typeof value && null !== value && false === Array.isArray(value) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | Record<string, string | number | (string | number)[]> | number | string | undefined)",
+            value: value
+        })) || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | Record<string, string | number | (string | number)[]> | number | string | undefined)",
+            value: value
+        }));
+    }).every(flag => flag)].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value || "number" === typeof value || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(number | string)",
+            value: value
+        });
+    }).every(flag => flag)].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return (null !== value || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | number | string)",
+            value: value
+        })) && (undefined !== value || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | number | string)",
+            value: value
+        })) && ("string" === typeof value || "number" === typeof value || (Array.isArray(value) || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | number | string)",
+            value: value
+        })) && value.map((elem, _index4) => "string" === typeof elem || "number" === typeof elem || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key) + "[" + _index4 + "]",
+            expected: "(number | string)",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "(Array<string | number> | number | string)",
+            value: value
+        }));
+    }).every(flag => flag)].every(flag => flag); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input, true); let errors; let _report; return __typia_transform__createStandardSchema._createStandardSchema(input => {
+    if (false === __is(input)) {
+        errors = [];
+        _report = __typia_transform__validateReport._validateReport(errors);
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
+            path: _path + "",
+            expected: "Meta",
+            value: input
+        })) && _vo0(input, _path + "", true) || _report(true, {
+            path: _path + "",
+            expected: "Meta",
+            value: input
+        }))(input, "$input", true);
+        const success = 0 === errors.length;
+        return success ? {
+            success,
+            data: input
+        } : {
+            success,
+            errors,
+            data: input
+        };
+    }
+    return {
+        success: true,
+        data: input
+    };
+}); })();
 //# sourceMappingURL=index.js.map

package/dist/Jobs/JobDefinition/meta/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/meta/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Jobs/JobDefinition/meta/index.ts"],"names":[],"mappings":";;;AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAQhD,MAAM,CAAC,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACW,CAAC"}