@nxtedition/types 23.0.40 → 23.0.42

package/dist/domains/revs.d.ts

@@ -1,13 +0,0 @@
-import { type AssertionGuard as __AssertionGuard } from "typia";
-export interface RevsDomainRecords {
-    ":revs?": RevsRecord;
-}
-export interface RevsRecord {
-    value?: string[];
-}
-export declare const isRevsRecord: (input: unknown) => input is RevsRecord;
-export declare const assertRevsRecord: (input: unknown) => RevsRecord;
-export declare const randomRevsRecord: () => RevsRecord;
-export declare const assertGuardRevsRecord: __AssertionGuard<RevsRecord>;
-export declare const stringifyRevsRecord: (input: RevsRecord) => string;
-export declare const assertStringifyRevsRecord: (input: unknown) => string;

package/dist/domains/revs.js

@@ -1,125 +0,0 @@
-import __typia from "typia";
-export const isRevsRecord = 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 assertRevsRecord = (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: "RevsRecord",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "RevsRecord",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-    return input;
-};
-export const randomRevsRecord = 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 assertGuardRevsRecord = (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: "RevsRecord",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "RevsRecord",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-};
-export const stringifyRevsRecord = 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 assertStringifyRevsRecord = (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: "RevsRecord",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "RevsRecord",
-                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/role.d.ts

@@ -1,13 +0,0 @@
-import { type AssertionGuard as __AssertionGuard } from "typia";
-export interface RoleDomainRecords {
-    ":role.tags": RoleTagsRecord;
-}
-export interface RoleTagsRecord {
-    value: string[];
-}
-export declare const isRoleTagsRecord: (input: unknown) => input is RoleTagsRecord;
-export declare const assertRoleTagsRecord: (input: unknown) => RoleTagsRecord;
-export declare const randomRoleTagsRecord: () => RoleTagsRecord;
-export declare const assertGuardRoleTagsRecord: __AssertionGuard<RoleTagsRecord>;
-export declare const stringifyRoleTagsRecord: (input: RoleTagsRecord) => string;
-export declare const assertStringifyRoleTagsRecord: (input: unknown) => string;

package/dist/domains/role.js

@@ -1,119 +0,0 @@
-import __typia from "typia";
-export const isRoleTagsRecord = input => {
-    const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
-    return "object" === typeof input && null !== input && $io0(input);
-};
-export const assertRoleTagsRecord = (input, errorFactory) => {
-    const __is = input => {
-        const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
-        return "object" === typeof input && null !== input && $io0(input);
-    };
-    if (false === __is(input))
-        ((input, _path, _exceptionable = true) => {
-            const $guard = __typia.createAssert.guard;
-            const $ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.value) || $guard(_exceptionable, {
-                path: _path + ".value",
-                expected: "Array<string>",
-                value: input.value
-            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".value[" + _index1 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".value",
-                expected: "Array<string>",
-                value: input.value
-            }, errorFactory);
-            return ("object" === typeof input && null !== input || $guard(true, {
-                path: _path + "",
-                expected: "RoleTagsRecord",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "RoleTagsRecord",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-    return input;
-};
-export const randomRoleTagsRecord = generator => {
-    const $generator = __typia.createRandom.generator;
-    const $ro0 = (_recursive = false, _depth = 0) => ({
-        value: (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
-    });
-    return $ro0();
-};
-export const assertGuardRoleTagsRecord = (input, errorFactory) => {
-    const __is = input => {
-        const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
-        return "object" === typeof input && null !== input && $io0(input);
-    };
-    if (false === __is(input))
-        ((input, _path, _exceptionable = true) => {
-            const $guard = __typia.createAssertGuard.guard;
-            const $ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.value) || $guard(_exceptionable, {
-                path: _path + ".value",
-                expected: "Array<string>",
-                value: input.value
-            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".value[" + _index1 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".value",
-                expected: "Array<string>",
-                value: input.value
-            }, errorFactory);
-            return ("object" === typeof input && null !== input || $guard(true, {
-                path: _path + "",
-                expected: "RoleTagsRecord",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "RoleTagsRecord",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-};
-export const stringifyRoleTagsRecord = input => {
-    const $string = __typia.json.createStringify.string;
-    const $so0 = input => `{"value":${`[${input.value.map(elem => $string(elem)).join(",")}]`}}`;
-    return $so0(input);
-};
-export const assertStringifyRoleTagsRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
-    const __is = input => {
-        const $io0 = input => Array.isArray(input.value) && input.value.every(elem => "string" === typeof elem);
-        return "object" === typeof input && null !== input && $io0(input);
-    };
-    if (false === __is(input))
-        ((input, _path, _exceptionable = true) => {
-            const $guard = __typia.json.createAssertStringify.guard;
-            const $ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.value) || $guard(_exceptionable, {
-                path: _path + ".value",
-                expected: "Array<string>",
-                value: input.value
-            }, errorFactory)) && input.value.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
-                path: _path + ".value[" + _index1 + "]",
-                expected: "string",
-                value: elem
-            }, errorFactory)) || $guard(_exceptionable, {
-                path: _path + ".value",
-                expected: "Array<string>",
-                value: input.value
-            }, errorFactory);
-            return ("object" === typeof input && null !== input || $guard(true, {
-                path: _path + "",
-                expected: "RoleTagsRecord",
-                value: input
-            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
-                path: _path + "",
-                expected: "RoleTagsRecord",
-                value: input
-            }, errorFactory);
-        })(input, "$input", true);
-    return input;
-}; const stringify = input => {
-    const $string = __typia.json.createAssertStringify.string;
-    const $so0 = input => `{"value":${`[${input.value.map(elem => $string(elem)).join(",")}]`}}`;
-    return $so0(input);
-}; return stringify(assert(input, errorFactory)); };

package/dist/domains/script.d.ts

@@ -1,263 +0,0 @@
-import { type AssertionGuard as __AssertionGuard } from "typia";
-import { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-/**
- * A base64 encoded string representing a complete Yjs document state.
- * This is created using `Y.encodeStateAsUpdate()` and is used for
- * persistence and versioning.
- */
-type YjsSnapshot = string;
-export interface ScriptDomainRecords {
-    ":script": ScriptRecord;
-    ":script?": ScriptEditorStateRecord;
-    ":script.revisions?": ScriptRevisionsRecord;
-    ":script.revision": ScriptRevisionRecord;
-    ":script.revision?": ScriptEditorStateRevisionRecord;
-    ":script.content?": ScriptContentRecord;
-    ":script.text?": ScriptTextRecord;
-    ":script.children": ScriptChildrenRecord;
-}
-export interface ScriptRecord {
-    value: YjsSnapshot;
-}
-export declare const isScriptRecord: (input: unknown) => input is ScriptRecord;
-export declare const assertScriptRecord: (input: unknown) => ScriptRecord;
-export declare const randomScriptRecord: () => ScriptRecord;
-export declare const assertGuardScriptRecord: __AssertionGuard<ScriptRecord>;
-export declare const stringifyScriptRecord: (input: ScriptRecord) => string;
-export declare const assertStringifyScriptRecord: (input: unknown) => string;
-export interface ScriptEditorStateRecord {
-    value: SerializedEditorState;
-}
-export declare const isScriptEditorStateRecord: (input: unknown) => input is ScriptEditorStateRecord;
-export declare const assertScriptEditorStateRecord: (input: unknown) => ScriptEditorStateRecord;
-export declare const randomScriptEditorStateRecord: () => {
-    value: {
-        root: {
-            type: string;
-            $?: {
-                [x: string]: unknown;
-            } | undefined;
-            version: number;
-            children: {
-                type: string;
-                version: number;
-                $?: {
-                    [x: string]: unknown;
-                } | undefined;
-            }[];
-            direction: "ltr" | "rtl" | null;
-            format: import("lexical").ElementFormatType;
-            indent: number;
-            textFormat?: number | undefined;
-            textStyle?: string | undefined;
-        };
-    };
-};
-export declare const assertGuardScriptEditorStateRecord: __AssertionGuard<ScriptEditorStateRecord>;
-export declare const stringifyScriptEditorStateRecord: (input: ScriptEditorStateRecord) => string;
-export declare const assertStringifyScriptEditorStateRecord: (input: unknown) => string;
-interface ScriptRevision {
-    id: string;
-    userId: string;
-}
-export interface ScriptRevisionsRecord {
-    value: ScriptRevision[];
-}
-export declare const isScriptRevisionsRecord: (input: unknown) => input is ScriptRevisionsRecord;
-export declare const assertScriptRevisionsRecord: (input: unknown) => ScriptRevisionsRecord;
-export declare const randomScriptRevisionsRecord: () => ScriptRevisionsRecord;
-export declare const assertGuardScriptRevisionsRecord: __AssertionGuard<ScriptRevisionsRecord>;
-export declare const stringifyScriptRevisionsRecord: (input: ScriptRevisionsRecord) => string;
-export declare const assertStringifyScriptRevisionsRecord: (input: unknown) => string;
-export interface ScriptRevisionRecord {
-    $parent: string;
-    scriptId: string;
-    userId: string;
-    value: YjsSnapshot;
-}
-export declare const isScriptRevisionRecord: (input: unknown) => input is ScriptRevisionRecord;
-export declare const assertScriptRevisionRecord: (input: unknown) => ScriptRevisionRecord;
-export declare const randomScriptRevisionRecord: () => ScriptRevisionRecord;
-export declare const assertGuardScriptRevisionRecord: __AssertionGuard<ScriptRevisionRecord>;
-export declare const stringifyScriptRevisionRecord: (input: ScriptRevisionRecord) => string;
-export declare const assertStringifyScriptRevisionRecord: (input: unknown) => string;
-export interface ScriptEditorStateRevisionRecord {
-    $parent: string;
-    scriptId: string;
-    userId: string;
-    value: SerializedEditorState;
-}
-export declare const isScriptEditorStateRevisionRecord: (input: unknown) => input is ScriptEditorStateRevisionRecord;
-export declare const assertScriptEditorStateRevisionRecord: (input: unknown) => ScriptEditorStateRevisionRecord;
-export declare const randomScriptEditorStateRevisionRecord: () => {
-    $parent: string;
-    scriptId: string;
-    userId: string;
-    value: {
-        root: {
-            type: string;
-            $?: {
-                [x: string]: unknown;
-            } | undefined;
-            version: number;
-            children: {
-                type: string;
-                version: number;
-                $?: {
-                    [x: string]: unknown;
-                } | undefined;
-            }[];
-            direction: "ltr" | "rtl" | null;
-            format: import("lexical").ElementFormatType;
-            indent: number;
-            textFormat?: number | undefined;
-            textStyle?: string | undefined;
-        };
-    };
-};
-export declare const assertGuardScriptEditorStateRevisionRecord: __AssertionGuard<ScriptEditorStateRevisionRecord>;
-export declare const stringifyScriptEditorStateRevisionRecord: (input: ScriptEditorStateRevisionRecord) => string;
-export declare const assertStringifyScriptEditorStateRevisionRecord: (input: unknown) => string;
-export interface EventNodeContent {
-    type: "event";
-    id: string;
-    mixin: string;
-    children: EventNodeContent[];
-}
-export declare const isEventNodeContent: (input: unknown) => input is EventNodeContent;
-export declare const assertEventNodeContent: (input: unknown) => EventNodeContent;
-export declare const randomEventNodeContent: () => EventNodeContent;
-export declare const assertGuardEventNodeContent: __AssertionGuard<EventNodeContent>;
-export declare const stringifyEventNodeContent: (input: EventNodeContent) => string;
-export declare const assertStringifyEventNodeContent: (input: unknown) => string;
-export interface TextNodeContent {
-    type: "text" | "link" | "autolink";
-    text: string;
-    style?: string;
-    format?: number;
-}
-export declare const isTextNodeContent: (input: unknown) => input is TextNodeContent;
-export declare const assertTextNodeContent: (input: unknown) => TextNodeContent;
-export declare const randomTextNodeContent: () => TextNodeContent;
-export declare const assertGuardTextNodeContent: __AssertionGuard<TextNodeContent>;
-export declare const stringifyTextNodeContent: (input: TextNodeContent) => string;
-export declare const assertStringifyTextNodeContent: (input: unknown) => string;
-export interface ElementNodeContent {
-    type: SerializedLexicalNode["type"];
-    children: TextNodeContent[];
-}
-export declare const isElementNodeContent: (input: unknown) => input is ElementNodeContent;
-export declare const assertElementNodeContent: (input: unknown) => ElementNodeContent;
-export declare const randomElementNodeContent: () => ElementNodeContent;
-export declare const assertGuardElementNodeContent: __AssertionGuard<ElementNodeContent>;
-export declare const stringifyElementNodeContent: (input: ElementNodeContent) => string;
-export declare const assertStringifyElementNodeContent: (input: unknown) => string;
-export interface ListItemNodeContent {
-    type: "listitem";
-    value: number;
-    checked?: boolean;
-    children: TextNodeContent[];
-}
-export declare const isListItemNodeContent: (input: unknown) => input is ListItemNodeContent;
-export declare const assertListItemNodeContent: (input: unknown) => ListItemNodeContent;
-export declare const randomListItemNodeContent: () => ListItemNodeContent;
-export declare const assertGuardListItemNodeContent: __AssertionGuard<ListItemNodeContent>;
-export declare const stringifyListItemNodeContent: (input: ListItemNodeContent) => string;
-export declare const assertStringifyListItemNodeContent: (input: unknown) => string;
-export interface ListNodeContent {
-    type: "list";
-    listType: "bullet" | "number" | "check";
-    tag: "ul" | "ol";
-    children: ListItemNodeContent[];
-}
-export declare const isListNodeContent: (input: unknown) => input is ListNodeContent;
-export declare const assertListNodeContent: (input: unknown) => ListNodeContent;
-export declare const randomListNodeContent: () => ListNodeContent;
-export declare const assertGuardListNodeContent: __AssertionGuard<ListNodeContent>;
-export declare const stringifyListNodeContent: (input: ListNodeContent) => string;
-export declare const assertStringifyListNodeContent: (input: unknown) => string;
-export interface ParagraphNodeContent extends ElementNodeContent {
-    type: "paragraph";
-}
-export declare const isParagraphNodeContent: (input: unknown) => input is ParagraphNodeContent;
-export declare const assertParagraphNodeContent: (input: unknown) => ParagraphNodeContent;
-export declare const randomParagraphNodeContent: () => ParagraphNodeContent;
-export declare const assertGuardParagraphNodeContent: __AssertionGuard<ParagraphNodeContent>;
-export declare const stringifyParagraphNodeContent: (input: ParagraphNodeContent) => string;
-export declare const assertStringifyParagraphNodeContent: (input: unknown) => string;
-export interface CommentNodeContent extends ElementNodeContent {
-    type: "comment";
-}
-export declare const isCommentNodeContent: (input: unknown) => input is CommentNodeContent;
-export declare const assertCommentNodeContent: (input: unknown) => CommentNodeContent;
-export declare const randomCommentNodeContent: () => CommentNodeContent;
-export declare const assertGuardCommentNodeContent: __AssertionGuard<CommentNodeContent>;
-export declare const stringifyCommentNodeContent: (input: CommentNodeContent) => string;
-export declare const assertStringifyCommentNodeContent: (input: unknown) => string;
-export interface HeadingNodeContent extends ElementNodeContent {
-    type: "heading";
-    tag: "h1" | "h2" | "h3";
-}
-export declare const isHeadingNodeContent: (input: unknown) => input is HeadingNodeContent;
-export declare const assertHeadingNodeContent: (input: unknown) => HeadingNodeContent;
-export declare const randomHeadingNodeContent: () => HeadingNodeContent;
-export declare const assertGuardHeadingNodeContent: __AssertionGuard<HeadingNodeContent>;
-export declare const stringifyHeadingNodeContent: (input: HeadingNodeContent) => string;
-export declare const assertStringifyHeadingNodeContent: (input: unknown) => string;
-export interface QuoteNodeContent extends ElementNodeContent {
-    type: "quote";
-}
-export declare const isQuoteNodeContent: (input: unknown) => input is QuoteNodeContent;
-export declare const assertQuoteNodeContent: (input: unknown) => QuoteNodeContent;
-export declare const randomQuoteNodeContent: () => QuoteNodeContent;
-export declare const assertGuardQuoteNodeContent: __AssertionGuard<QuoteNodeContent>;
-export declare const stringifyQuoteNodeContent: (input: QuoteNodeContent) => string;
-export declare const assertStringifyQuoteNodeContent: (input: unknown) => string;
-export interface HorizontalRuleContent {
-    type: "horizontalrule";
-}
-export declare const isHorizontalRuleContent: (input: unknown) => input is HorizontalRuleContent;
-export declare const assertHorizontalRuleContent: (input: unknown) => HorizontalRuleContent;
-export declare const randomHorizontalRuleContent: () => HorizontalRuleContent;
-export declare const assertGuardHorizontalRuleContent: __AssertionGuard<HorizontalRuleContent>;
-export declare const stringifyHorizontalRuleContent: (input: HorizontalRuleContent) => string;
-export declare const assertStringifyHorizontalRuleContent: (input: unknown) => string;
-export type NodeContent = EventNodeContent | TextNodeContent | ParagraphNodeContent | CommentNodeContent | ListNodeContent | ListItemNodeContent | HeadingNodeContent | HorizontalRuleContent | QuoteNodeContent;
-export declare const isNodeContent: (input: unknown) => input is NodeContent;
-export declare const assertNodeContent: (input: unknown) => NodeContent;
-export declare const randomNodeContent: () => NodeContent;
-export declare const assertGuardNodeContent: __AssertionGuard<NodeContent>;
-export declare const stringifyNodeContent: (input: NodeContent) => string;
-export declare const assertStringifyNodeContent: (input: unknown) => string;
-export interface ScriptContentRecord {
-    nodes: NodeContent[];
-}
-export declare const isScriptContentRecord: (input: unknown) => input is ScriptContentRecord;
-export declare const assertScriptContentRecord: (input: unknown) => ScriptContentRecord;
-export declare const randomScriptContentRecord: () => ScriptContentRecord;
-export declare const assertGuardScriptContentRecord: __AssertionGuard<ScriptContentRecord>;
-export declare const stringifyScriptContentRecord: (input: ScriptContentRecord) => string;
-export declare const assertStringifyScriptContentRecord: (input: unknown) => string;
-export interface ScriptTextRecord {
-    content: string;
-    graphics: string;
-}
-export declare const isScriptTextRecord: (input: unknown) => input is ScriptTextRecord;
-export declare const assertScriptTextRecord: (input: unknown) => ScriptTextRecord;
-export declare const randomScriptTextRecord: () => ScriptTextRecord;
-export declare const assertGuardScriptTextRecord: __AssertionGuard<ScriptTextRecord>;
-export declare const stringifyScriptTextRecord: (input: ScriptTextRecord) => string;
-export declare const assertStringifyScriptTextRecord: (input: unknown) => string;
-/**
- * A record for non-script automation assets that can have child events.
- */
-export interface ScriptChildrenRecord {
-    value?: string[];
-}
-export declare const isScriptChildrenRecord: (input: unknown) => input is ScriptChildrenRecord;
-export declare const assertScriptChildrenRecord: (input: unknown) => ScriptChildrenRecord;
-export declare const randomScriptChildrenRecord: () => ScriptChildrenRecord;
-export declare const assertGuardScriptChildrenRecord: __AssertionGuard<ScriptChildrenRecord>;
-export declare const stringifyScriptChildrenRecord: (input: ScriptChildrenRecord) => string;
-export declare const assertStringifyScriptChildrenRecord: (input: unknown) => string;
-export {};