@nxtedition/types 1.0.0

package/dist/domains/permission.js

@@ -0,0 +1,375 @@
+import __typia from "typia";
+export const isPermissionRecord = input => {
+    const $io0 = input => Array.isArray(input.permissions) && input.permissions.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && $io1(elem));
+    const $io1 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem));
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertPermissionRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.permissions) && input.permissions.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && $io1(elem));
+        const $io1 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.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.permissions) || $guard(_exceptionable, {
+                path: _path + ".permissions",
+                expected: "Array<PermissionRecordPermisson>",
+                value: input.permissions
+            }, errorFactory)) && input.permissions.every((elem, _index1) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || $guard(_exceptionable, {
+                path: _path + ".permissions[" + _index1 + "]",
+                expected: "PermissionRecordPermisson",
+                value: elem
+            }, errorFactory)) && $ao1(elem, _path + ".permissions[" + _index1 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".permissions[" + _index1 + "]",
+                expected: "PermissionRecordPermisson",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".permissions",
+                expected: "Array<PermissionRecordPermisson>",
+                value: input.permissions
+            }, errorFactory);
+            const $ao1 = (input, _path, _exceptionable = true) => (undefined === input.type || "string" === typeof input.type || $guard(_exceptionable, {
+                path: _path + ".type",
+                expected: "(string | undefined)",
+                value: input.type
+            }, errorFactory)) && (undefined === input.method || "string" === typeof input.method || $guard(_exceptionable, {
+                path: _path + ".method",
+                expected: "(string | undefined)",
+                value: input.method
+            }, errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".tags[" + _index2 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPermissionRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        permissions: (generator?.array ?? $generator.array)(() => $ro1(_recursive, _recursive ? 1 + _depth : _depth))
+    });
+    const $ro1 = (_recursive = false, _depth = 0) => ({
+        type: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        method: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        tags: $pick([
+            () => undefined,
+            () => (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardPermissionRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.permissions) && input.permissions.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && $io1(elem));
+        const $io1 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.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.permissions) || $guard(_exceptionable, {
+                path: _path + ".permissions",
+                expected: "Array<PermissionRecordPermisson>",
+                value: input.permissions
+            }, errorFactory)) && input.permissions.every((elem, _index1) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || $guard(_exceptionable, {
+                path: _path + ".permissions[" + _index1 + "]",
+                expected: "PermissionRecordPermisson",
+                value: elem
+            }, errorFactory)) && $ao1(elem, _path + ".permissions[" + _index1 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".permissions[" + _index1 + "]",
+                expected: "PermissionRecordPermisson",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".permissions",
+                expected: "Array<PermissionRecordPermisson>",
+                value: input.permissions
+            }, errorFactory);
+            const $ao1 = (input, _path, _exceptionable = true) => (undefined === input.type || "string" === typeof input.type || $guard(_exceptionable, {
+                path: _path + ".type",
+                expected: "(string | undefined)",
+                value: input.type
+            }, errorFactory)) && (undefined === input.method || "string" === typeof input.method || $guard(_exceptionable, {
+                path: _path + ".method",
+                expected: "(string | undefined)",
+                value: input.method
+            }, errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".tags[" + _index2 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPermissionRecord = input => {
+    const $io1 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem));
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{"permissions":${`[${input.permissions.map(elem => $so1(elem)).join(",")}]`}}`;
+    const $so1 = input => `{${$tail(`${undefined === input.type ? "" : `"type":${undefined !== input.type ? $string(input.type) : undefined},`}${undefined === input.method ? "" : `"method":${undefined !== input.method ? $string(input.method) : undefined},`}${undefined === input.tags ? "" : `"tags":${undefined !== input.tags ? `[${input.tags.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyPermissionRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => Array.isArray(input.permissions) && input.permissions.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && $io1(elem));
+        const $io1 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.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.permissions) || $guard(_exceptionable, {
+                path: _path + ".permissions",
+                expected: "Array<PermissionRecordPermisson>",
+                value: input.permissions
+            }, errorFactory)) && input.permissions.every((elem, _index1) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || $guard(_exceptionable, {
+                path: _path + ".permissions[" + _index1 + "]",
+                expected: "PermissionRecordPermisson",
+                value: elem
+            }, errorFactory)) && $ao1(elem, _path + ".permissions[" + _index1 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".permissions[" + _index1 + "]",
+                expected: "PermissionRecordPermisson",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".permissions",
+                expected: "Array<PermissionRecordPermisson>",
+                value: input.permissions
+            }, errorFactory);
+            const $ao1 = (input, _path, _exceptionable = true) => (undefined === input.type || "string" === typeof input.type || $guard(_exceptionable, {
+                path: _path + ".type",
+                expected: "(string | undefined)",
+                value: input.type
+            }, errorFactory)) && (undefined === input.method || "string" === typeof input.method || $guard(_exceptionable, {
+                path: _path + ".method",
+                expected: "(string | undefined)",
+                value: input.method
+            }, errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory)) && input.tags.every((elem, _index2) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".tags[" + _index2 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem));
+    const $string = __typia.json.createAssertStringify.string;
+    const $tail = __typia.json.createAssertStringify.tail;
+    const $so0 = input => `{"permissions":${`[${input.permissions.map(elem => $so1(elem)).join(",")}]`}}`;
+    const $so1 = input => `{${$tail(`${undefined === input.type ? "" : `"type":${undefined !== input.type ? $string(input.type) : undefined},`}${undefined === input.method ? "" : `"method":${undefined !== input.method ? $string(input.method) : undefined},`}${undefined === input.tags ? "" : `"tags":${undefined !== input.tags ? `[${input.tags.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isPermissionRecordPermisson = input => {
+    const $io0 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.every(elem => "string" === typeof elem));
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertPermissionRecordPermisson = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.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.type || "string" === typeof input.type || $guard(_exceptionable, {
+                path: _path + ".type",
+                expected: "(string | undefined)",
+                value: input.type
+            }, errorFactory)) && (undefined === input.method || "string" === typeof input.method || $guard(_exceptionable, {
+                path: _path + ".method",
+                expected: "(string | undefined)",
+                value: input.method
+            }, errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory)) && input.tags.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".tags[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecordPermisson",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecordPermisson",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomPermissionRecordPermisson = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        type: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        method: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        tags: $pick([
+            () => undefined,
+            () => (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardPermissionRecordPermisson = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.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.type || "string" === typeof input.type || $guard(_exceptionable, {
+                path: _path + ".type",
+                expected: "(string | undefined)",
+                value: input.type
+            }, errorFactory)) && (undefined === input.method || "string" === typeof input.method || $guard(_exceptionable, {
+                path: _path + ".method",
+                expected: "(string | undefined)",
+                value: input.method
+            }, errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory)) && input.tags.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".tags[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecordPermisson",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecordPermisson",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyPermissionRecordPermisson = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.type ? "" : `"type":${undefined !== input.type ? $string(input.type) : undefined},`}${undefined === input.method ? "" : `"method":${undefined !== input.method ? $string(input.method) : undefined},`}${undefined === input.tags ? "" : `"tags":${undefined !== input.tags ? `[${input.tags.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyPermissionRecordPermisson = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.type || "string" === typeof input.type) && (undefined === input.method || "string" === typeof input.method) && (undefined === input.tags || Array.isArray(input.tags) && input.tags.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.type || "string" === typeof input.type || $guard(_exceptionable, {
+                path: _path + ".type",
+                expected: "(string | undefined)",
+                value: input.type
+            }, errorFactory)) && (undefined === input.method || "string" === typeof input.method || $guard(_exceptionable, {
+                path: _path + ".method",
+                expected: "(string | undefined)",
+                value: input.method
+            }, errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory)) && input.tags.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".tags[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".tags",
+                expected: "(Array<string> | undefined)",
+                value: input.tags
+            }, errorFactory));
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecordPermisson",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "PermissionRecordPermisson",
+                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.type ? "" : `"type":${undefined !== input.type ? $string(input.type) : undefined},`}${undefined === input.method ? "" : `"method":${undefined !== input.method ? $string(input.method) : undefined},`}${undefined === input.tags ? "" : `"tags":${undefined !== input.tags ? `[${input.tags.map(elem => $string(elem)).join(",")}]` : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/domains/publish.d.ts

@@ -0,0 +1,213 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+import type { Message, RpcMethods } from '../common/index.js';
+export interface PublishDomainRecords {
+    [":publish"]: PublishRecord;
+    [":publish.stats?"]: PublishStatsRecord;
+    [":publish.methods?"]: RpcMethods;
+}
+export type PublishRecord = YoutubePublishRecord | FacebookPublishRecord | FilePublishRecord;
+export declare const isPublishRecord: (input: unknown) => input is PublishRecord;
+export declare const assertPublishRecord: (input: unknown) => PublishRecord;
+export declare const randomPublishRecord: () => PublishRecord;
+export declare const assertGuardPublishRecord: __AssertionGuard<PublishRecord>;
+export declare const stringifyPublishRecord: (input: PublishRecord) => string;
+export declare const assertStringifyPublishRecord: (input: unknown) => string;
+export type PublishStatsRecord = YoutubePublishStatsRecord | FacebookPublishStatsRecord | FilePublishStatsRecord;
+export declare const isPublishStatsRecord: (input: unknown) => input is PublishStatsRecord;
+export declare const assertPublishStatsRecord: (input: unknown) => PublishStatsRecord;
+export declare const randomPublishStatsRecord: () => PublishStatsRecord;
+export declare const assertGuardPublishStatsRecord: __AssertionGuard<PublishStatsRecord>;
+export declare const stringifyPublishStatsRecord: (input: PublishStatsRecord) => string;
+export declare const assertStringifyPublishStatsRecord: (input: unknown) => string;
+interface PublishRecordCommon<Type extends PublishRecord["type"]> {
+    type: Type;
+    asset?: string;
+    connection?: string;
+    render?: unknown;
+    draft?: Record<string, unknown>;
+    published?: Record<string, unknown>;
+    remote?: Record<string, unknown>;
+    error?: {
+        method: string;
+    } | null;
+    messages?: Message[];
+}
+export interface PublishStatsRecordCommon {
+    status?: string;
+    substatus?: string;
+    messages?: Message[];
+    retrieved?: Record<string, unknown>;
+    defaults?: Record<string, unknown>;
+}
+export declare const isPublishStatsRecordCommon: (input: unknown) => input is PublishStatsRecordCommon;
+export declare const assertPublishStatsRecordCommon: (input: unknown) => PublishStatsRecordCommon;
+export declare const randomPublishStatsRecordCommon: () => PublishStatsRecordCommon;
+export declare const assertGuardPublishStatsRecordCommon: __AssertionGuard<PublishStatsRecordCommon>;
+export declare const stringifyPublishStatsRecordCommon: (input: PublishStatsRecordCommon) => string;
+export declare const assertStringifyPublishStatsRecordCommon: (input: unknown) => string;
+export interface YoutubePublishRecord extends PublishRecordCommon<"youtube"> {
+    draft?: {
+        snippet?: {
+            title?: string;
+            tags?: string[];
+            description?: string;
+        };
+    };
+}
+export declare const isYoutubePublishRecord: (input: unknown) => input is YoutubePublishRecord;
+export declare const assertYoutubePublishRecord: (input: unknown) => YoutubePublishRecord;
+export declare const randomYoutubePublishRecord: () => YoutubePublishRecord;
+export declare const assertGuardYoutubePublishRecord: __AssertionGuard<YoutubePublishRecord>;
+export declare const stringifyYoutubePublishRecord: (input: YoutubePublishRecord) => string;
+export declare const assertStringifyYoutubePublishRecord: (input: unknown) => string;
+export type YoutubePublishStatsRecord = PublishStatsRecordCommon;
+export declare const isYoutubePublishStatsRecord: (input: unknown) => input is PublishStatsRecordCommon;
+export declare const assertYoutubePublishStatsRecord: (input: unknown) => PublishStatsRecordCommon;
+export declare const randomYoutubePublishStatsRecord: () => PublishStatsRecordCommon;
+export declare const assertGuardYoutubePublishStatsRecord: __AssertionGuard<YoutubePublishStatsRecord>;
+export declare const stringifyYoutubePublishStatsRecord: (input: PublishStatsRecordCommon) => string;
+export declare const assertStringifyYoutubePublishStatsRecord: (input: unknown) => string;
+export interface FacebookPublishRecord extends PublishRecordCommon<"facebook"> {
+    pageId?: string;
+}
+export declare const isFacebookPublishRecord: (input: unknown) => input is FacebookPublishRecord;
+export declare const assertFacebookPublishRecord: (input: unknown) => FacebookPublishRecord;
+export declare const randomFacebookPublishRecord: () => FacebookPublishRecord;
+export declare const assertGuardFacebookPublishRecord: __AssertionGuard<FacebookPublishRecord>;
+export declare const stringifyFacebookPublishRecord: (input: FacebookPublishRecord) => string;
+export declare const assertStringifyFacebookPublishRecord: (input: unknown) => string;
+export type FacebookPublishStatsRecord = PublishStatsRecordCommon;
+export declare const isFacebookPublishStatsRecord: (input: unknown) => input is PublishStatsRecordCommon;
+export declare const assertFacebookPublishStatsRecord: (input: unknown) => PublishStatsRecordCommon;
+export declare const randomFacebookPublishStatsRecord: () => PublishStatsRecordCommon;
+export declare const assertGuardFacebookPublishStatsRecord: __AssertionGuard<FacebookPublishStatsRecord>;
+export declare const stringifyFacebookPublishStatsRecord: (input: PublishStatsRecordCommon) => string;
+export declare const assertStringifyFacebookPublishStatsRecord: (input: unknown) => string;
+export interface FilePublishRecord extends PublishRecordCommon<"file"> {
+    directory?: string;
+    filename?: string;
+    renders?: Record<string, FilePublishRender>;
+    draft?: FilePublishDraft;
+    remote?: FilePublishRemote;
+    published?: FilePublishPublished;
+}
+export declare const isFilePublishRecord: (input: unknown) => input is FilePublishRecord;
+export declare const assertFilePublishRecord: (input: unknown) => FilePublishRecord;
+export declare const randomFilePublishRecord: () => FilePublishRecord;
+export declare const assertGuardFilePublishRecord: __AssertionGuard<FilePublishRecord>;
+export declare const stringifyFilePublishRecord: (input: FilePublishRecord) => string;
+export declare const assertStringifyFilePublishRecord: (input: unknown) => string;
+export interface FilePublishRender {
+    name?: string;
+    path?: string;
+    collisionStrategy?: "overwrite" | "skip";
+    preset?: string;
+    type?: string;
+    profile?: unknown;
+    scene?: string;
+}
+export declare const isFilePublishRender: (input: unknown) => input is FilePublishRender;
+export declare const assertFilePublishRender: (input: unknown) => FilePublishRender;
+export declare const randomFilePublishRender: () => FilePublishRender;
+export declare const assertGuardFilePublishRender: __AssertionGuard<FilePublishRender>;
+export declare const stringifyFilePublishRender: (input: FilePublishRender) => string;
+export declare const assertStringifyFilePublishRender: (input: unknown) => string;
+export interface FilePublishPublished extends Record<string, unknown> {
+    directory?: string;
+    filename?: string;
+}
+export declare const isFilePublishPublished: (input: unknown) => input is FilePublishPublished;
+export declare const assertFilePublishPublished: (input: unknown) => FilePublishPublished;
+export declare const randomFilePublishPublished: () => FilePublishPublished;
+export declare const assertGuardFilePublishPublished: __AssertionGuard<FilePublishPublished>;
+export declare const stringifyFilePublishPublished: (input: FilePublishPublished) => string;
+export declare const assertStringifyFilePublishPublished: (input: unknown) => string;
+export interface FilePublishDraft extends Record<string, unknown> {
+    directory?: string;
+    filename?: string;
+}
+export declare const isFilePublishDraft: (input: unknown) => input is FilePublishDraft;
+export declare const assertFilePublishDraft: (input: unknown) => FilePublishDraft;
+export declare const randomFilePublishDraft: () => FilePublishDraft;
+export declare const assertGuardFilePublishDraft: __AssertionGuard<FilePublishDraft>;
+export declare const stringifyFilePublishDraft: (input: FilePublishDraft) => string;
+export declare const assertStringifyFilePublishDraft: (input: unknown) => string;
+export interface FilePublishRemote extends Record<string, unknown> {
+    directory?: string;
+    filename?: string;
+    renders?: Record<string, FilePublishRemoteRender>;
+}
+export declare const isFilePublishRemote: (input: unknown) => input is FilePublishRemote;
+export declare const assertFilePublishRemote: (input: unknown) => FilePublishRemote;
+export declare const randomFilePublishRemote: () => FilePublishRemote;
+export declare const assertGuardFilePublishRemote: __AssertionGuard<FilePublishRemote>;
+export declare const stringifyFilePublishRemote: (input: FilePublishRemote) => string;
+export declare const assertStringifyFilePublishRemote: (input: unknown) => string;
+export interface FilePublishRemoteRender {
+    path?: string;
+    messages?: Message[];
+    query?: unknown;
+    size?: string;
+    hash?: string;
+    source?: string;
+}
+export declare const isFilePublishRemoteRender: (input: unknown) => input is FilePublishRemoteRender;
+export declare const assertFilePublishRemoteRender: (input: unknown) => FilePublishRemoteRender;
+export declare const randomFilePublishRemoteRender: () => FilePublishRemoteRender;
+export declare const assertGuardFilePublishRemoteRender: __AssertionGuard<FilePublishRemoteRender>;
+export declare const stringifyFilePublishRemoteRender: (input: FilePublishRemoteRender) => string;
+export declare const assertStringifyFilePublishRemoteRender: (input: unknown) => string;
+export interface FilePublishStatsRecord extends PublishStatsRecordCommon {
+    retrieved?: FilePublishRetrieved;
+    defaults?: FilePublishDefaults;
+}
+export declare const isFilePublishStatsRecord: (input: unknown) => input is FilePublishStatsRecord;
+export declare const assertFilePublishStatsRecord: (input: unknown) => FilePublishStatsRecord;
+export declare const randomFilePublishStatsRecord: () => FilePublishStatsRecord;
+export declare const assertGuardFilePublishStatsRecord: __AssertionGuard<FilePublishStatsRecord>;
+export declare const stringifyFilePublishStatsRecord: (input: FilePublishStatsRecord) => string;
+export declare const assertStringifyFilePublishStatsRecord: (input: unknown) => string;
+export interface FilePublishRetrieved extends Record<string, unknown> {
+    filename?: string;
+    directory?: string;
+    renders?: Record<string, FilePublishRetrievedRender>;
+}
+export declare const isFilePublishRetrieved: (input: unknown) => input is FilePublishRetrieved;
+export declare const assertFilePublishRetrieved: (input: unknown) => FilePublishRetrieved;
+export declare const randomFilePublishRetrieved: () => FilePublishRetrieved;
+export declare const assertGuardFilePublishRetrieved: __AssertionGuard<FilePublishRetrieved>;
+export declare const stringifyFilePublishRetrieved: (input: FilePublishRetrieved) => string;
+export declare const assertStringifyFilePublishRetrieved: (input: unknown) => string;
+export interface FilePublishRetrievedRender {
+    path: string;
+    size?: string;
+    hash?: string;
+}
+export declare const isFilePublishRetrievedRender: (input: unknown) => input is FilePublishRetrievedRender;
+export declare const assertFilePublishRetrievedRender: (input: unknown) => FilePublishRetrievedRender;
+export declare const randomFilePublishRetrievedRender: () => FilePublishRetrievedRender;
+export declare const assertGuardFilePublishRetrievedRender: __AssertionGuard<FilePublishRetrievedRender>;
+export declare const stringifyFilePublishRetrievedRender: (input: FilePublishRetrievedRender) => string;
+export declare const assertStringifyFilePublishRetrievedRender: (input: unknown) => string;
+export interface FilePublishDefaults extends Record<string, unknown> {
+    directory: string;
+    filename: string;
+    renders: Record<string, FilePublishDefaultRender>;
+}
+export declare const isFilePublishDefaults: (input: unknown) => input is FilePublishDefaults;
+export declare const assertFilePublishDefaults: (input: unknown) => FilePublishDefaults;
+export declare const randomFilePublishDefaults: () => FilePublishDefaults;
+export declare const assertGuardFilePublishDefaults: __AssertionGuard<FilePublishDefaults>;
+export declare const stringifyFilePublishDefaults: (input: FilePublishDefaults) => string;
+export declare const assertStringifyFilePublishDefaults: (input: unknown) => string;
+export interface FilePublishDefaultRender {
+    path?: string;
+    collisionStrategy?: "skip" | "overwrite";
+}
+export declare const isFilePublishDefaultRender: (input: unknown) => input is FilePublishDefaultRender;
+export declare const assertFilePublishDefaultRender: (input: unknown) => FilePublishDefaultRender;
+export declare const randomFilePublishDefaultRender: () => FilePublishDefaultRender;
+export declare const assertGuardFilePublishDefaultRender: __AssertionGuard<FilePublishDefaultRender>;
+export declare const stringifyFilePublishDefaultRender: (input: FilePublishDefaultRender) => string;
+export declare const assertStringifyFilePublishDefaultRender: (input: unknown) => string;
+export {};