@endge/core 1.2.5

package/dist/domain/entities/reflect/RComponent.d.ts

@@ -0,0 +1,25 @@
+import { RComponent } from '../../types/component.types';
+import { DuplicateOptions } from './REntity';
+/**
+ * Создает экземпляр ComponentModel из JSON-объекта.
+ * Ожидается, что JSON имеет следующие поля:
+ *  - name: строка
+ *  - type: строка
+ *  - template: строка с HTML-шаблоном (например, "<div>{{var1}}</div>")
+ *  - "vars-shapes": массив объектов вида { var: string, shape: { ... } }
+ *  - input: объект, описывающий входной тип
+ *
+ * @param json JSON-объект с описанием компонента.
+ * @returns Новый экземпляр ComponentModel.
+ */
+export declare function ReflectComponentFromPlain(json: Record<string, any>): RComponent | null;
+export declare function ReflectComponentToPlain(component: RComponent): Record<string, any>;
+/**
+ * Полная копия компонента с новым identity и именем (в корне).
+ * Сохраняет всю внутреннюю структуру (колонки таблицы, DSL и т.д.).
+ */
+export declare function duplicateComponent(component: RComponent, options: DuplicateOptions): RComponent;
+/**
+ * Строит объект для PATCH/POST компонента в Payload (flat-поля, без использования schema).
+ */
+export declare function ReflectComponentToPayloadData(component: RComponent, componentIdentityToId: Map<string, number>, converterIdentityToId: Map<string, number>): Record<string, any>;

package/dist/domain/entities/reflect/RComponentBase.d.ts

@@ -0,0 +1,39 @@
+import { RField } from './RField';
+import { ComponentKind } from '../../types/types';
+import { REntity } from './REntity';
+import { DependencyGraph } from '../data/DependencyGraph';
+import { RaphNode } from '@endge/raph';
+import { ExecuteOptions } from '../../types/runtime.types';
+import { UILegacyComponentRenderHost } from '../../types/ui-composition.types';
+import { ComponentType } from '../../types/document.types';
+/**
+ * RComponent – дескриптор компонента.
+ * Он описывает шаблон, переменные и схему извлечения данных (varsShapes),
+ * а также входной тип данных (reflectField).
+ */
+export declare class RComponentBase extends REntity {
+    kind: ComponentKind;
+    type: ComponentType;
+    customRenderer: unknown | null;
+    customRenderersByHost: Map<string, unknown>;
+    varsPaths: Map<string, string>;
+    inputFields: Record<string, RField>;
+    setupScript: string;
+    exportedNames: Set<string>;
+    depGraph: DependencyGraph | null;
+    producerComponentPath: string[];
+    runtimeFilters: string[];
+    constructor();
+    compile(): void;
+    execute(options: ExecuteOptions): RaphNode;
+    getDependencyComponentIds(): Array<string | number>;
+    extractDeclaredFns(): void;
+    /**
+     * Генерирует граф зависимости для этого компонента.
+     */
+    generateDependencyGraph(): void;
+    setRenderer(renderer: unknown | null, input?: {
+        host?: UILegacyComponentRenderHost;
+    }): void;
+    getRenderer(host?: UILegacyComponentRenderHost): unknown | null;
+}

package/dist/domain/entities/reflect/RComponentDSL.d.ts

@@ -0,0 +1,14 @@
+import { RComponentBase } from './RComponentBase';
+import { RootNode } from '@vue/compiler-dom';
+import { DataPath } from '@endge/raph';
+export declare class RComponentDSL extends RComponentBase {
+    jsxScript: string;
+    ast: RootNode | null;
+    requiredVars: Set<string>;
+    requiredFns: Set<string>;
+    varsPaths: Map<string, DataPath>;
+    constructor();
+    compile(): void;
+    getDependencyComponentIds(): string[];
+    generateVarPaths(): void;
+}

package/dist/domain/entities/reflect/RComponentTable.d.ts

@@ -0,0 +1,21 @@
+import { RComponentBase } from './RComponentBase';
+import { RComponentTableColumn } from './RComponentTableColumn';
+import { RaphNode } from '@endge/raph';
+import { ExecuteOptions } from '../../types/runtime.types';
+import { TableBinding } from '../../types/models.types';
+export declare class RComponentTable extends RComponentBase {
+    columns: Array<RComponentTableColumn>;
+    sourceIndex: string;
+    bindings: TableBinding;
+    rowSize: string | number | 'zoom';
+    dataPaths: Set<string>;
+    constructor();
+    compile(): void;
+    execute(options: ExecuteOptions): RaphNode;
+    /**
+     * Рекурсивно находит конечный DependencyNode по dataPath.
+     */
+    private findNodeByDataPath;
+    getDependencyComponentIds(): Array<string | number>;
+    get rowSizeCalc(): string | number | 'zoom';
+}

package/dist/domain/entities/reflect/RComponentTableColumn.d.ts

@@ -0,0 +1,64 @@
+import { RComponentHtml } from './RComponentHtml';
+import { RField } from './RField';
+import { EndgeEventBinding } from '../../types/events.types';
+import { ColumnSortConfig } from '../../types/table.types';
+import { Constructor } from '@endge/utils';
+import { ColumnComponentType } from '../../types/component.types';
+export declare class ReflectComponentTableColumnBase {
+    id: string;
+    isActive: boolean;
+    title: string;
+    type: ColumnComponentType;
+    dataPaths: Record<string, string>;
+    dataConverters: Record<string, string>;
+    width: number;
+    pin: 'left' | 'right' | 'none';
+    sort: ColumnSortConfig | null;
+    /**
+     * Конфигурация отчетов.
+     *
+     * - null/undefined/{} => "по умолчанию": все dataPaths включены, форматирование базовое
+     * - либо объект по ключам dataPaths:
+     *
+     * reports: {
+     *   data: {
+     *     enabled: true,
+     *     formatter: { type: 'DateTime', format: 'DD/MM/YYYY' }
+     *   }
+     * }
+     */
+    reports: Record<string, {
+        enabled?: boolean;
+        formatter?: {
+            type?: string;
+            format?: string;
+        };
+    }> | null;
+    eventBindings: EndgeEventBinding[];
+    toPlain(): Record<string, any>;
+    fromPlain(json: Record<string, any>): void;
+}
+export declare class ReflectComponentTableColumnHtml extends ReflectComponentTableColumnBase {
+    template: string | null;
+    htmlComponent: RComponentHtml | null;
+    toPlain(): Record<string, any>;
+    fromPlain(json: Record<string, any>): void;
+}
+export declare class ReflectComponentTableColumnComponent extends ReflectComponentTableColumnBase {
+    componentId: number | null;
+    getInputs(): Record<string, RField>;
+    toPlain(): Record<string, any>;
+    fromPlain(json: Record<string, any>): void;
+}
+export type RComponentTableColumn = ReflectComponentTableColumnHtml | ReflectComponentTableColumnComponent;
+/**
+ * Маппер типов
+ */
+export declare const ColumnTypeMap: Record<ColumnComponentType, Constructor<RComponentTableColumn>>;
+/**
+ * Безопасный конструктор для типа.
+ * Возвращает конструктор колонки в зависимости от типа.
+ */
+export declare function RComponentTableColumn_TypeCtor(type: ColumnComponentType): Constructor<RComponentTableColumn> | null;
+export declare function RComponentTableColumn_isComponent(column: RComponentTableColumn): column is ReflectComponentTableColumnComponent;
+export declare function RComponentTableColumn_isHtml(column: RComponentTableColumn): column is ReflectComponentTableColumnHtml;

package/dist/domain/entities/reflect/RConverter.d.ts

@@ -0,0 +1,14 @@
+import { REntity } from './REntity';
+export interface RConverterSchema {
+    id: number;
+    name: string;
+    description?: string | null;
+    isSystem?: boolean;
+}
+export declare class RConverter extends REntity {
+    description: string | null;
+    customHandler: ((v: any) => any) | undefined;
+    setCustom(fn: ((v: any) => any) | undefined): void;
+    convert(v: any): any;
+    toPlain(): RConverterSchema;
+}

package/dist/domain/entities/reflect/REntity.d.ts

@@ -0,0 +1,47 @@
+/** Опции для дублирования сущности: новый identity и опционально имя. */
+export interface DuplicateOptions {
+    identity: string;
+    name?: string;
+}
+export declare class REntity {
+    /** Идентификатор в storage (Payload: number, plain: string | number) */
+    id: number;
+    identity: string;
+    /** Человекочитаемое имя документа */
+    displayName: string;
+    name: string;
+    description: string | null;
+    /** Id папки, в которой расположен документ (связь по id). */
+    folderId?: string | number | null;
+    /** Проект (identity или null). Только для фильтра в виджете домена. */
+    project?: string | null;
+    /** Системный документ (нельзя редактировать/сохранять в редакторе) */
+    isSystem: boolean;
+    /** Временная сущность runtime/editor, не должна отображаться как обычный документ домена. */
+    isTemporary: boolean;
+    inherited: boolean;
+    /** Произвольные метаданные (из Payload meta, по умолчанию {}). */
+    meta: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string | null;
+    author?: string | null;
+    active?: boolean | null;
+    protected validationErrors: string[];
+    /**
+     * Добавляет ошибку в массив (используется внутри наследников).
+     */
+    protected addValidationError(message: string): void;
+    /**
+     * Очищает все ошибки.
+     */
+    protected clearValidationErrors(): void;
+    /** Подмешивает storage-мета и meta из Payload */
+    applyStorageMeta(raw: any): void;
+    compile(): void;
+    /**
+     * Возвращает полную копию сущности с новым identity и именем (в корне, folderId = null).
+     * Переопределяется в наследниках для корректного глубокого копирования структуры.
+     */
+    duplicate(_options: DuplicateOptions): REntity;
+}

package/dist/domain/entities/reflect/REnvironment.d.ts

@@ -0,0 +1,6 @@
+import { DuplicateOptions, REntity } from './REntity';
+/** Сущность окружения (коллекция environments). Без привязки к проекту. */
+export declare class REnvironment extends REntity {
+    toPlain(): Record<string, unknown>;
+    duplicate(options: DuplicateOptions): REnvironment;
+}

package/dist/domain/entities/reflect/RField.d.ts

@@ -0,0 +1,9 @@
+export declare class RField {
+    name: string;
+    type: string;
+    isArray: boolean;
+    optional: boolean;
+    params?: Map<string, RField>;
+    constructor(name: string, type: string, isArray?: boolean, optional?: boolean, params?: Map<string, RField>);
+    isMethod(): boolean;
+}

package/dist/domain/entities/reflect/RFilter.d.ts

@@ -0,0 +1,11 @@
+import { FilterFieldItemSchema, RFilterSchema } from '../../types/filter.types';
+import { DomainDocumentType } from '../../types/document.types';
+import { REntity } from './REntity';
+export declare class RFilter extends REntity {
+    displayName: string;
+    fields: FilterFieldItemSchema[];
+    get type(): DomainDocumentType;
+    static fromPayload(raw: any): RFilter;
+    static fromPlain(json: RFilterSchema): RFilter;
+    toPlain(): RFilterSchema;
+}

package/dist/domain/entities/reflect/RFolder.d.ts

@@ -0,0 +1,23 @@
+import { REntity } from './REntity';
+/**
+ * Доменная сущность для папок (folders).
+ *
+ * Может быть создана:
+ *  - из payload-формата (с полями id, identity, displayName...)
+ *  - из plain-domain-формата (schema)
+ */
+export declare class RFolder extends REntity {
+    /** Отображаемое имя папки */
+    displayName: string;
+    /** Тип сущностей, для которых предназначена папка (collection slug в Payload). */
+    entityType: string | null;
+    /** Id родительской папки (null если корень). */
+    parent: string | number | null;
+    /** Загружает папку из формата Payload */
+    static fromPayload(json: any): RFolder;
+    /** Загружает папку из plain-schema (schema.toPlain()) */
+    static fromPlain(json: any): RFolder;
+    /** Экспорт только схемы (parent уже id в plain). */
+    toPlain(): any;
+    compile(): void;
+}

package/dist/domain/entities/reflect/RI18nBundle.d.ts

@@ -0,0 +1,16 @@
+import { DuplicateOptions, REntity } from './REntity';
+/** Дерево сообщений по локали (формат vue-i18n). */
+export type RI18nBundleLocales = Record<string, Record<string, unknown>>;
+/** Сущность словаря переводов (коллекция i18n-bundles). Один документ = словарь с несколькими локалями. */
+export declare class RI18nBundle extends REntity {
+    displayName: string;
+    description?: string | null;
+    /** По коду локали (ru, en) — дерево ключ→значение. */
+    locales: RI18nBundleLocales;
+    active: boolean;
+    static fromPayload(json: any): RI18nBundle;
+    static fromPlain(json: any): RI18nBundle;
+    toPlain(): Record<string, unknown>;
+    compile(): void;
+    duplicate(options: DuplicateOptions): RI18nBundle;
+}

package/dist/domain/entities/reflect/RIntegration.d.ts

@@ -0,0 +1,13 @@
+import { DuplicateOptions, REntity } from './REntity';
+export interface RIntegrationSchema {
+    id: string;
+    name: string;
+    description?: string | null;
+    isSystem?: boolean;
+}
+/** Сущность интеграции (коллекция integrations). */
+export declare class RIntegration extends REntity {
+    description: string | null;
+    toPlain(): RIntegrationSchema;
+    duplicate(options: DuplicateOptions): RIntegration;
+}

package/dist/domain/entities/reflect/RNavigation.d.ts

@@ -0,0 +1,24 @@
+import { DuplicateOptions, REntity } from './REntity';
+import { DomainDocumentType } from '../../types/document.types';
+import { NavigationTreeNodeDoc } from '../../types/navigation.types';
+export interface RNavigationSchema {
+    id: string;
+    identity: string;
+    name: string;
+    displayName?: string;
+    description?: string | null;
+    isSystem?: boolean;
+    folderId?: string | number | null;
+    project?: string | number | null;
+    tree?: NavigationTreeNodeDoc[];
+    meta?: Record<string, unknown>;
+}
+/** Навигация (коллекция navigations). */
+export declare class RNavigation extends REntity {
+    description: string | null;
+    tree: NavigationTreeNodeDoc[];
+    /** Тип документа для редактора/инспектора. */
+    get type(): DomainDocumentType;
+    toPlain(): RNavigationSchema;
+    duplicate(options: DuplicateOptions): RNavigation;
+}

package/dist/domain/entities/reflect/RPage.d.ts

@@ -0,0 +1,45 @@
+import { DuplicateOptions, REntity } from './REntity';
+import { DomainDocumentType } from '../../types/document.types';
+export interface RPageAreaBlockSchema {
+    key: string;
+    entityType?: string | null;
+    /** Целочисленный id документа в Payload (relation value). */
+    entityId?: number | null;
+    /** Identity сущности (для отображения и fallback при сохранении). */
+    entityIdentity?: string | null;
+    titleOverride?: string | null;
+    visibleWhen?: string | null;
+    props?: Record<string, unknown> | null;
+}
+export interface RPageAreaSchema {
+    slotId: string;
+    blocks?: RPageAreaBlockSchema[];
+}
+export interface RPageSchema {
+    id: number;
+    identity: string;
+    name: string;
+    description?: string | null;
+    isSystem?: boolean;
+    routeName?: string | null;
+    routePath?: string | null;
+    templateId?: number | null;
+    controllerId?: number | null;
+    enabled?: boolean;
+    areas?: RPageAreaSchema[];
+    meta?: Record<string, unknown>;
+}
+/** Страница приложения (коллекция pages). */
+export declare class RPage extends REntity {
+    description: string | null;
+    routeName: string | null;
+    routePath: string | null;
+    templateId: number | null;
+    controllerId: number | null;
+    enabled: boolean;
+    areas: RPageAreaSchema[];
+    /** Тип документа для редактора/инспектора. */
+    get type(): DomainDocumentType;
+    toPlain(): RPageSchema;
+    duplicate(options: DuplicateOptions): RPage;
+}

package/dist/domain/entities/reflect/RPageTemplate.d.ts

@@ -0,0 +1,32 @@
+import { DuplicateOptions, REntity } from './REntity';
+import { DomainDocumentType } from '../../types/document.types';
+export interface RPageTemplateAreaSchema {
+    identity: string;
+    title?: string | null;
+    description?: string | null;
+}
+/** short | normal | tall - высота строки в превью. */
+export type RPageTemplatePreviewRowHeight = 'short' | 'normal' | 'tall';
+export interface RPageTemplatePreviewSchema {
+    rows: string[][];
+    rowHeights?: RPageTemplatePreviewRowHeight[];
+}
+export interface RPageTemplateSchema {
+    id: string;
+    name: string;
+    description?: string | null;
+    isSystem?: boolean;
+    areas?: RPageTemplateAreaSchema[];
+    preview?: RPageTemplatePreviewSchema | null;
+    meta?: Record<string, unknown>;
+}
+/** Шаблон страницы (коллекция page-templates). */
+export declare class RPageTemplate extends REntity {
+    description: string | null;
+    areas: RPageTemplateAreaSchema[];
+    preview: RPageTemplatePreviewSchema | null;
+    /** Тип документа для редактора/инспектора. */
+    get type(): DomainDocumentType;
+    toPlain(): RPageTemplateSchema;
+    duplicate(options: DuplicateOptions): RPageTemplate;
+}

package/dist/domain/entities/reflect/RParameter.d.ts

@@ -0,0 +1,13 @@
+import { FilterFieldSchema, RParameterSchema, RuntimeFilterLinkEntity } from '../../types/query.types';
+import { DomainDocumentType } from '../../types/document.types';
+import { REntity } from './REntity';
+export declare class RParameter extends REntity {
+    displayName: string;
+    description?: string;
+    fields: Map<string, FilterFieldSchema>;
+    runtimeFilters: RuntimeFilterLinkEntity[];
+    get type(): DomainDocumentType;
+    static fromPayload(raw: any): RParameter;
+    static fromPlain(json: RParameterSchema): RParameter;
+    toPlain(): RParameterSchema;
+}

package/dist/domain/entities/reflect/RPolicy.d.ts

@@ -0,0 +1,7 @@
+import { DuplicateOptions, REntity } from './REntity';
+/** Сущность политики (коллекция policies). identity, displayName, description, folder. */
+export declare class RPolicy extends REntity {
+    description?: string | null;
+    toPlain(): Record<string, unknown>;
+    duplicate(options: DuplicateOptions): RPolicy;
+}

package/dist/domain/entities/reflect/RPresentationBinding.d.ts

@@ -0,0 +1,20 @@
+import { EndgeBindingMode } from '../../types/resolve.types';
+import { REntity } from './REntity';
+/** Сущность биндинга отображения (коллекция presentation-bindings). */
+export declare class RPresentationBinding extends REntity {
+    projectId: number | null;
+    ownerType: string;
+    ownerId: number | null;
+    targetType: string;
+    targetId: number | null;
+    role: string;
+    rendererRef: string;
+    when: string | null;
+    mode: EndgeBindingMode;
+    priority: number;
+    isEnabled: boolean;
+    environmentId: number | null;
+    isInherited: boolean;
+    originBindingId: number | null;
+    toPlain(): Record<string, unknown>;
+}

package/dist/domain/entities/reflect/RProject.d.ts

@@ -0,0 +1,68 @@
+import { REntity } from './REntity';
+/**
+ * Доменная сущность для проекта (projects).
+ *
+ * Схема (schema-часть):
+ *  - id: string            // identity или строковый id
+ *  - identity: string
+ *  - name: string
+ *  - displayName: string
+ *  - extendSettings: boolean
+ *
+ * Storage-мета (через REntity.applyStorageMeta):
+ *  - createdAt, updatedAt, deletedAt, author, active
+ */
+export declare class RProject extends REntity {
+    /** Отображаемое имя проекта */
+    displayName: string;
+    /** Наследоваться ли от базовых настроек */
+    extendSettings: boolean;
+    /** Описание проекта */
+    description?: string | null;
+    /** Slug (URL-имя) */
+    slug?: string | null;
+    /** Порядок сортировки в списке */
+    order?: number | null;
+    /** Id профиля настроек (relationship → settings) */
+    settingsId?: number | null;
+    /** Id навигации (relationship → navigations) */
+    navigationId?: number | null;
+    /** Список разрешённых окружений проекта (relationship[] → environments). */
+    allowedEnvironmentIds: number[];
+    /**
+     * Создание проекта из payload-документа:
+     *
+     * {
+     *   id: number,
+     *   identity: string,
+     *   displayName: string,
+     *   "extend-settings": boolean,
+     *   deletedAt?: string | null,
+     *   author?: string,
+     *   createdAt?: string,
+     *   updatedAt?: string,
+     *   ...
+     * }
+     */
+    static fromPayload(json: any): RProject;
+    /**
+     * Создание проекта из plain-схемы (schema.toPlain()).
+     *
+     * Ожидается структура:
+     * {
+     *   id: string
+     *   identity?: string
+     *   name?: string
+     *   displayName?: string
+     *   folder?: string | null
+     *   extendSettings?: boolean
+     * }
+     */
+    static fromPlain(json: any): RProject;
+    /**
+     * Экспорт только схемы (без storage-меты).
+     * Используется в EndgeDomain.toPlain().
+     */
+    toPlain(): any;
+    compile(): void;
+}

package/dist/domain/entities/reflect/RQuery.d.ts

@@ -0,0 +1,43 @@
+import { QueryType } from '../../types/document.types';
+import { RQueryAuth, RQueryFilterApplyMode } from '../../types/query.types';
+import { Nullable } from '@endge/utils';
+import { DuplicateOptions, REntity } from './REntity';
+import { RField } from './RField';
+import { RQueryFilter } from './RQueryFilter';
+export declare class RQuery extends REntity {
+    type: QueryType;
+    query: string;
+    returnField: RField;
+    endpoint: string;
+    subField: string;
+    params: Map<string, RField>;
+    mockData: string;
+    mockDataEnabled: boolean;
+    auth: RQueryAuth;
+    customExecutor: Nullable<() => Promise<any>>;
+    customGenerator: Nullable<(opts: {
+        count: number;
+    }) => Promise<any>>;
+    /** Режим применения списка фильтров (пока только слияние). */
+    filterMode: RQueryFilterApplyMode;
+    filters: RQueryFilter[];
+    constructor(name?: string, returnField?: RField);
+    /**
+     * Установка кастомных функций генерации и выполнения запроса
+     * @param opts.executor - функция выполнения запроса
+     * @param opts.generator - функция генерации данных (для моков)
+     */
+    override(opts: {
+        executor?: () => Promise<any>;
+        generator?: (opts: {
+            count: number;
+        }) => Promise<any>;
+    }): void;
+    addParam(name: string, type: RField): void;
+    getParams(): Map<string, RField>;
+    /**
+     * Выполнение запроса
+     */
+    run(params?: object): Promise<any>;
+    duplicate(options: DuplicateOptions): RQuery;
+}

package/dist/domain/entities/reflect/RQueryFilter.d.ts

@@ -0,0 +1,12 @@
+/** Режим элемента фильтра: свой JSON или ссылка на фильтр из коллекции. */
+export type RQueryFilterItemMode = 'inline' | 'reference';
+/**
+ * Один элемент фильтра запроса: либо inline JSON, либо ссылка на доменный фильтр (parameters).
+ */
+export declare class RQueryFilter {
+    mode: RQueryFilterItemMode;
+    /** Identity фильтра из коллекции (parameters), если mode === 'reference'. */
+    filterId: string | null;
+    inlineJson: string | null;
+    constructor(init?: Partial<RQueryFilter>);
+}

package/dist/domain/entities/reflect/RQueryRest.d.ts

@@ -0,0 +1,21 @@
+import { RQuery } from './RQuery';
+import { HttpMethod } from '../../types/query.types';
+export declare class RQueryRest extends RQuery {
+    /** HTTP-метод (по умолчанию POST) */
+    method: HttpMethod;
+    /** Заголовки по умолчанию для этого запроса */
+    headers: Record<string, string>;
+    /** Таймаут HTTP-запроса в миллисекундах (опционально) */
+    timeoutMs?: number;
+    /**
+     * Режим сериализации тела:
+     * - false: тело как JSON (по умолчанию)
+     * - true: тело как application/x-www-form-urlencoded (URLSearchParams)
+     */
+    sendAsFormUrlencoded: boolean;
+    /**
+     * Проверка конфигурации на этапе компиляции домена.
+     * (вызывается EndgeDomain.compile()).
+     */
+    compile(): void;
+}

package/dist/domain/entities/reflect/RScenario.d.ts

@@ -0,0 +1,20 @@
+import { DuplicateOptions, REntity } from './REntity';
+import { RuntimeScope } from '../runtime/RuntimeScope';
+import { ScriptType } from '../../types/document.types';
+export declare class RScenario extends REntity {
+    type: ScriptType;
+    setupScript: string;
+    previewQuery: object;
+    /**
+     * Компиляция сценария
+     */
+    compile(): void;
+    /**
+     * Запуск сценария
+     */
+    runner(): {
+        run: () => Promise<void>;
+        scope: RuntimeScope;
+    };
+    duplicate(options: DuplicateOptions): RScenario;
+}