@nxtedition/types 1.0.0

package/dist/domains/asset.d.ts

@@ -0,0 +1,23 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface AssetDomainRecords {
+    ":asset.title?": AssetTitleRecord;
+    ":asset.types?": AssetTypesRecord;
+}
+export interface AssetTitleRecord {
+    value?: string;
+}
+export declare const isAssetTitleRecord: (input: unknown) => input is AssetTitleRecord;
+export declare const assertAssetTitleRecord: (input: unknown) => AssetTitleRecord;
+export declare const randomAssetTitleRecord: () => AssetTitleRecord;
+export declare const assertGuardAssetTitleRecord: __AssertionGuard<AssetTitleRecord>;
+export declare const stringifyAssetTitleRecord: (input: AssetTitleRecord) => string;
+export declare const assertStringifyAssetTitleRecord: (input: unknown) => string;
+export interface AssetTypesRecord {
+    value?: string[];
+}
+export declare const isAssetTypesRecord: (input: unknown) => input is AssetTypesRecord;
+export declare const assertAssetTypesRecord: (input: unknown) => AssetTypesRecord;
+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;

package/dist/domains/asset.js

@@ -0,0 +1,225 @@
+import __typia from "typia";
+export const isAssetTitleRecord = input => {
+    const $io0 = input => undefined === input.value || "string" === typeof input.value;
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertAssetTitleRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || "string" === typeof input.value;
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(string | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTitleRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTitleRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomAssetTitleRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        value: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardAssetTitleRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || "string" === typeof input.value;
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(string | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTitleRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTitleRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyAssetTitleRecord = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.value ? "" : `"value":${undefined !== input.value ? $string(input.value) : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyAssetTitleRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.value || "string" === typeof input.value;
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.value || "string" === typeof input.value || $guard(_exceptionable, {
+                path: _path + ".value",
+                expected: "(string | undefined)",
+                value: input.value
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTitleRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTitleRecord",
+                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 ? $string(input.value) : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isAssetTypesRecord = 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 assertAssetTypesRecord = (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: "AssetTypesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTypesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomAssetTypesRecord = 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 assertGuardAssetTypesRecord = (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: "AssetTypesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTypesRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyAssetTypesRecord = 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 assertStringifyAssetTypesRecord = (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: "AssetTypesRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "AssetTypesRecord",
+                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

@@ -0,0 +1,62 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface ConnectionDomainRecords {
+    [":connection"]: ConnectionRecord;
+    [":connection.methods?"]: Record<string, object>;
+    [":connection.stats?"]: ConnectionStatsRecord;
+}
+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 assertGuardConnectionRecord: __AssertionGuard<ConnectionRecord>;
+export declare const stringifyConnectionRecord: (input: ConnectionRecord) => string;
+export declare const assertStringifyConnectionRecord: (input: unknown) => string;
+export interface ConnectionStatsRecord {
+    status: string;
+    substatus: string;
+    pages?: Array<{
+        id: unknown;
+    }>;
+}
+export declare const isConnectionStatsRecord: (input: unknown) => input is ConnectionStatsRecord;
+export declare const assertConnectionStatsRecord: (input: unknown) => ConnectionStatsRecord;
+export declare const randomConnectionStatsRecord: () => ConnectionStatsRecord;
+export declare const assertGuardConnectionStatsRecord: __AssertionGuard<ConnectionStatsRecord>;
+export declare const stringifyConnectionStatsRecord: (input: ConnectionStatsRecord) => string;
+export declare const assertStringifyConnectionStatsRecord: (input: unknown) => string;
+export interface ReutersConnectionRecord {
+    type: "reuters";
+    clientId?: string;
+    clientSecret?: string;
+    audience?: string;
+}
+export declare const isReutersConnectionRecord: (input: unknown) => input is ReutersConnectionRecord;
+export declare const assertReutersConnectionRecord: (input: unknown) => ReutersConnectionRecord;
+export declare const randomReutersConnectionRecord: () => ReutersConnectionRecord;
+export declare const assertGuardReutersConnectionRecord: __AssertionGuard<ReutersConnectionRecord>;
+export declare const stringifyReutersConnectionRecord: (input: ReutersConnectionRecord) => string;
+export declare const assertStringifyReutersConnectionRecord: (input: unknown) => string;
+export interface FacebookConnectionRecord {
+    type: "facebook";
+    grantedScopes?: string[];
+}
+export declare const isFacebookConnectionRecord: (input: unknown) => input is FacebookConnectionRecord;
+export declare const assertFacebookConnectionRecord: (input: unknown) => FacebookConnectionRecord;
+export declare const randomFacebookConnectionRecord: () => FacebookConnectionRecord;
+export declare const assertGuardFacebookConnectionRecord: __AssertionGuard<FacebookConnectionRecord>;
+export declare const stringifyFacebookConnectionRecord: (input: FacebookConnectionRecord) => string;
+export declare const assertStringifyFacebookConnectionRecord: (input: unknown) => string;
+export interface FilePublishConnectionRecord {
+    type: "file";
+    protocol: string;
+    host?: string;
+    port?: number;
+    ignoreMissing?: boolean;
+    concurrency?: number;
+}
+export declare const isFilePublishConnectionRecord: (input: unknown) => input is FilePublishConnectionRecord;
+export declare const assertFilePublishConnectionRecord: (input: unknown) => FilePublishConnectionRecord;
+export declare const randomFilePublishConnectionRecord: () => FilePublishConnectionRecord;
+export declare const assertGuardFilePublishConnectionRecord: __AssertionGuard<FilePublishConnectionRecord>;
+export declare const stringifyFilePublishConnectionRecord: (input: FilePublishConnectionRecord) => string;
+export declare const assertStringifyFilePublishConnectionRecord: (input: unknown) => string;