@endge/core 1.2.5 → 1.2.7

package/dist/domain/types/source/source-engine.types.d.ts

@@ -0,0 +1,188 @@
+/** Канонический тип source-документа, для которого выбирается source strategy. */
+export type SourceKind = 'query' | 'data-view' | 'filter' | 'composition' | 'store' | 'computation' | 'style' | 'type';
+/** Тип нейтральной source completion без привязки к Monaco или другому editor API. */
+export type SourceLanguageCompletionKind = 'keyword' | 'function' | 'property' | 'value' | 'snippet';
+/** Позиция курсора внутри source-документа. */
+export interface SourceLanguagePosition {
+    /** Номер строки, начиная с 1. */
+    lineNumber: number;
+    /** Номер колонки, начиная с 1. */
+    column: number;
+}
+/** Контекст, который UI/editor adapter передает language strategy. */
+export interface SourceLanguageContext {
+    /** Текущий текст source-документа. */
+    source: string;
+    /** Текущая позиция курсора, если она есть у editor adapter. */
+    position?: SourceLanguagePosition;
+    /** Source-backed Type Registry symbols available to this editor. */
+    typeSymbols?: Array<{
+        identity: string;
+        displayName?: string;
+        category?: 'primitive' | 'reference' | 'user';
+    }>;
+    /** Identity of the document that owns current source diagnostics. */
+    ownerIdentity?: string;
+}
+/** Нейтральная completion item, которую editor adapter мапит в свой формат. */
+export interface SourceLanguageCompletion {
+    /** Текст, отображаемый в списке подсказок. */
+    label: string;
+    /** Семантический тип подсказки. */
+    kind: SourceLanguageCompletionKind;
+    /** Текст, который нужно вставить. Может быть snippet-ом. */
+    insertText: string;
+    /** Краткое описание справа от completion item. */
+    detail?: string;
+    /** Документация completion item. */
+    documentation?: string;
+}
+/** Логический тип внешнего доменного документа, на который ссылается source. */
+export type SourceDocumentReferenceTarget = 'auth-profile' | 'component' | 'composition' | 'computation' | 'converter' | 'data-view' | 'filter' | 'mock' | 'query' | 'store' | 'style' | 'type' | 'vocabs';
+/** Семантическая ссылка из source на внешний доменный документ. */
+export interface SourceDocumentReference {
+    /** Логический тип цели; UI может уточнить concrete document type через domain. */
+    target: SourceDocumentReferenceTarget;
+    /** Persisted identity целевого документа. */
+    identity: string;
+    /** Полуоткрытый диапазон reference-expression в source offsets. */
+    range: {
+        start: number;
+        end: number;
+    };
+}
+/** Renderer-neutral semantic emphasis for one source range. */
+export interface SourceLanguageSemanticHighlight {
+    kind: 'type-reference';
+    status: 'resolved' | 'unresolved';
+    identity: string;
+    range: SourceDocumentReference['range'];
+}
+/** Результат validation source language strategy. */
+export interface SourceLanguageValidationResult extends SourceEngineResult {
+    /** Diagnostics, найденные language strategy. */
+    diagnostics: unknown[];
+}
+/** Минимальная операция source engine. Детальные операции появятся вместе с patch engine. */
+export interface SourceEngineOperation {
+    /** Тип операции, например replace-slot или insert-block. */
+    type: string;
+    /** Дополнительный payload операции. */
+    payload?: Record<string, unknown>;
+}
+/** Базовый результат source operation до внедрения полноценного patch engine. */
+export interface SourceEngineResult {
+    /** Было ли действие обработано стратегией. */
+    ok: boolean;
+    /** Машинное сообщение об ошибке или причине no-op. */
+    message?: string;
+}
+/** Результат генерации source из persisted/legacy модели. */
+export interface SourceEngineGenerateResult extends SourceEngineResult {
+    /** Сгенерированный source-документ. */
+    source?: string;
+    /** Нормализованный source document, если стратегия его построила. */
+    document?: unknown;
+}
+/** Результат компиляции source в normalized document и runtime artifact payload. */
+export interface SourceEngineCompileResult extends SourceEngineResult {
+    /** Parser-level AST. */
+    ast?: unknown;
+    /** Нормализованный source document. */
+    document?: unknown;
+    /** Runtime/program-ready artifact payload. */
+    artifact?: any;
+    /** Публичная metadata, извлечённая из source. */
+    metadata?: import('../program/program-metadata.types').ProgramMetadataMap;
+    /** Diagnostics, найденные source compiler-ом. */
+    diagnostics?: unknown[];
+}
+/** Результат parse source без обязательной runtime-компиляции. */
+export interface SourceParseResult<TDocument = unknown> extends SourceEngineResult {
+    /** Parser-level AST. */
+    ast?: unknown;
+    /** Нормализованный source document. */
+    document?: TDocument;
+    /** Diagnostics, найденные parser/compiler-ом. */
+    diagnostics?: unknown[];
+}
+/** Результат patch source-документа. */
+export interface SourcePatchResult<TDocument = unknown> extends SourceParseResult<TDocument> {
+    /** Новый source-документ. */
+    source: string;
+    /** Был ли source реально изменен. */
+    changed: boolean;
+}
+/** Strategy source patching для одного source-kind. */
+export interface SourcePatchStrategy<TPatch = unknown, TDocument = unknown> {
+    /** Стабильный id стратегии для debug/плагинов. */
+    id: string;
+    /** Тип source-документа, который обслуживает стратегия. */
+    sourceKind: SourceKind;
+    /** Проверяет, может ли стратегия обслужить переданный source-kind. */
+    supports: (sourceKind: SourceKind | string) => boolean;
+    /** Парсит source в editor-facing normalized document. */
+    parse: (source: string) => SourceParseResult<TDocument>;
+    /** Применяет минимальный patch, сохраняя остальной авторский source. */
+    patch: (source: string, patch: TPatch) => SourcePatchResult<TDocument>;
+}
+/** Strategy source engine для одного source-kind. */
+export interface SourceEngineStrategy {
+    /** Стабильный id стратегии для debug/плагинов. */
+    id: string;
+    /** Тип source-документа, который обслуживает стратегия. */
+    sourceKind: SourceKind;
+    /** Проверяет, может ли стратегия обслужить переданный source-kind. */
+    supports: (sourceKind: SourceKind | string) => boolean;
+    /** Выполняет нейтральную source operation. Пока используется как будущий контракт patch/analyze API. */
+    execute?: (operation: SourceEngineOperation) => SourceEngineResult;
+    /** Генерирует source из persisted/legacy модели. */
+    generate?: (model: unknown) => SourceEngineGenerateResult;
+    /** Компилирует source в normalized document и artifact payload. */
+    compile?: (source: string) => SourceEngineCompileResult;
+}
+/** Нейтральный token pattern source-языка, не завязанный на Monaco API. */
+export interface SourceLanguageTokenPattern {
+    pattern: RegExp;
+    token: string;
+    next?: string;
+}
+/** Editor-facing синтаксис, которым владеет SourceLanguageStrategy. */
+export interface SourceLanguageSyntaxDefinition {
+    aliases: string[];
+    extensions: string[];
+    comments: {
+        lineComment: string;
+        blockComment: [string, string];
+    };
+    brackets: Array<[string, string]>;
+    autoClosingPairs: Array<{
+        open: string;
+        close: string;
+    }>;
+    triggerCharacters: string[];
+    tokenizer: Record<string, SourceLanguageTokenPattern[]>;
+}
+/** Strategy source language для editor-facing операций одного source-kind. */
+export interface SourceLanguageStrategy {
+    /** Стабильный id стратегии для debug/плагинов. */
+    id: string;
+    /** Тип source-документа, который обслуживает стратегия. */
+    sourceKind: SourceKind;
+    /** Проверяет, может ли стратегия обслужить переданный source-kind. */
+    supports: (sourceKind: SourceKind | string) => boolean;
+    /** Описывает подсветку, brackets и editor triggers в adapter-neutral формате. */
+    syntax: SourceLanguageSyntaxDefinition;
+    /** Возвращает базовый source для новой сущности. */
+    createDefaultSource: () => string;
+    /** Нормализует поддержанный syntax, сохраняя остальной авторский source. */
+    normalize?: (source: string) => string;
+    /** Валидирует source без знания о конкретном editor adapter. */
+    validate: (source: string, context?: SourceLanguageContext) => SourceLanguageValidationResult;
+    /** Возвращает доступные подсказки языка в нейтральном формате. */
+    completions: (context: SourceLanguageContext) => SourceLanguageCompletion[];
+    /** Возвращает внешнюю document reference под курсором, если язык её поддерживает. */
+    resolveReference?: (context: SourceLanguageContext) => SourceDocumentReference | null;
+    /** Возвращает semantic highlights без привязки к конкретному editor adapter. */
+    semanticHighlights?: (context: SourceLanguageContext) => SourceLanguageSemanticHighlight[];
+}

package/dist/domain/types/source/source-expression.types.d.ts

@@ -0,0 +1,98 @@
+/** Type Registry identity used by Query/Filter field contracts. */
+export type SourceFieldType = 'String' | 'Number' | 'Boolean' | 'Date' | 'Time' | 'DateTime' | 'Object' | 'Any' | (string & {});
+/** Источник безопасного чтения значения внутри source expression. */
+export type SourceExpressionReadKind = 'env' | 'prop' | 'value' | 'row' | 'response' | 'store' | 'current' | 'scope' | 'composition-output' | 'composition-outputs' | 'composition-data' | 'composition-store' | 'composition-filter-fields' | 'composition-runtime-metadata' | 'metadata' | 'computation-output';
+/** Whitelist операций статического expression IR. */
+export type SourceExpressionOperation = 'merge' | 'compact' | 'get' | 'get-or' | 'has' | 'default-to' | 'pick' | 'omit' | 'defaults' | 'keys' | 'values' | 'entries' | 'map' | 'where' | 'reject' | 'find' | 'some' | 'every' | 'flat-map' | 'flatten' | 'uniq' | 'uniq-by' | 'concat' | 'take' | 'drop' | 'sort-by' | 'group-by' | 'key-by' | 'size' | 'sum' | 'sum-by' | 'min' | 'max' | 'min-by' | 'max-by' | 'trim' | 'lower-case' | 'upper-case' | 'split' | 'join' | 'match' | 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'includes' | 'or' | 'when' | 'not' | 'is-nil' | 'is-empty' | 'and' | 'between' | 'in-list' | 'in-array' | 'relative-date' | 'relative-date-time' | 'left-join' | 'full-join' | 'join-by' | 'join-by-any' | 'join-coalesce' | 'lookup-one' | 'lookup-many' | 'enrich';
+/**
+ * Безопасное runtime-выражение, полученное из source callback.
+ *
+ * IR не содержит исполняемого JavaScript и вычисляется только штатным evaluator-ом.
+ */
+export type SourceExpressionIR = {
+    type: 'literal';
+    value: unknown;
+} | {
+    type: 'object';
+    properties: Record<string, SourceExpressionIR>;
+} | {
+    type: 'array';
+    items: SourceExpressionIR[];
+} | {
+    type: 'read';
+    source: SourceExpressionReadKind;
+    path: string;
+    parameters?: string[];
+} | {
+    type: 'operation';
+    operation: SourceExpressionOperation;
+    arguments: SourceExpressionIR[];
+};
+/** Статический вариант выбора source-field. */
+export interface SourceFieldOption {
+    value: string | number | boolean;
+    label?: string;
+}
+/** Ссылка source-field на доменный vocab. */
+export interface SourceFieldVocab {
+    identity: string;
+    valuePath: string;
+    labelPath: string;
+}
+/** Общий compiled field contract для Filter и Query props. */
+export interface SourceFieldDefinition {
+    key: string;
+    type: SourceFieldType;
+    optional: boolean;
+    array: boolean;
+    defaultValue?: SourceExpressionIR;
+    options?: SourceFieldOption[];
+    vocab?: SourceFieldVocab;
+}
+/** Default value prop, вычисляемый через output внешнего или локального Filter. */
+export type SourceFieldDefaultSource = {
+    kind: 'filter';
+    identity: string;
+    output: string;
+} | {
+    kind: 'inline-filter';
+    source: string;
+    output: string;
+} | {
+    kind: 'local-filter';
+    ref: {
+        entityType: 'filter';
+        id: string | number;
+        identity: string;
+    };
+    output: string;
+};
+/** Query prop на базе общего field contract. */
+export interface QueryProgramProp extends SourceFieldDefinition {
+    defaultSource?: SourceFieldDefaultSource;
+}
+/** Контекст вычисления безопасного source expression. */
+export interface SourceExpressionContext {
+    /** Resolves an env(name) read without exposing the workspace to the evaluator. */
+    environment?: (name: string) => unknown;
+    props?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+    row?: unknown;
+    response?: unknown;
+    stores?: Record<string, unknown>;
+    current?: unknown;
+    scope?: unknown;
+    read?: (expression: Extract<SourceExpressionIR, {
+        type: 'read';
+    }>) => unknown;
+    onWarning?: (warning: SourceExpressionWarning) => void;
+}
+/** Публичное имя общего декларативного value DSL. */
+export type ValueExpressionIR = SourceExpressionIR;
+export type ValueExpressionContext = SourceExpressionContext;
+/** Runtime warning безопасного expression evaluator. */
+export interface SourceExpressionWarning {
+    code: string;
+    message: string;
+    data?: unknown;
+}

package/dist/domain/types/source/store-source.types.d.ts

@@ -0,0 +1,33 @@
+import { ProgramDiagnostic } from '../program/program.types';
+import { EndgeMockReference } from '../mock';
+import { DataViewRef } from './data-view-source.types';
+export type StoreDataDescriptor = StoreValueDescriptor | StoreDerivedDescriptor;
+export interface StoreValueDescriptor {
+    key: string;
+    kind: 'value';
+    initial: StoreValueInitializer;
+}
+export type StoreValueInitializer = {
+    kind: 'literal';
+    value: unknown;
+} | EndgeMockReference;
+export interface StoreDerivedDescriptor {
+    key: string;
+    kind: 'derived';
+    source: string;
+    dataViews: DataViewRef[];
+}
+export interface StoreSourceDocument {
+    data: StoreDataDescriptor[];
+}
+/** Runtime-ready Store source artifact v1. */
+export interface StoreSourceArtifact extends StoreSourceDocument {
+    type: 'store';
+    sourceVersion: number;
+}
+export interface StoreSourceCompileResult {
+    ast: unknown | null;
+    document: StoreSourceDocument | null;
+    artifact: StoreSourceArtifact | null;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+}

package/dist/domain/types/source/type-source.types.d.ts

@@ -0,0 +1,75 @@
+import { ProgramDiagnostic } from '../program/program.types';
+/** Ссылка Type Source на примитивный или пользовательский тип домена. */
+export interface TypeSourceReference {
+    kind: 'reference';
+    identity: string;
+}
+/** Поле объектного Type Source v1. */
+export interface TypeSourceField {
+    key: string;
+    type: TypeSourceExpression;
+    description?: string;
+    optional: boolean;
+    array: boolean;
+    min?: number;
+    max?: number;
+    examples: unknown[];
+}
+export interface TypeSourceObjectDefinition {
+    kind: 'object';
+    fields: TypeSourceField[];
+}
+export interface TypeSourceEnumDefinition {
+    kind: 'enum';
+    values: Array<string | number | boolean>;
+}
+export interface TypeSourceUnionDefinition {
+    kind: 'union';
+    variants: TypeSourceExpression[];
+}
+export interface TypeSourceArrayDefinition {
+    kind: 'array';
+    items: TypeSourceExpression;
+}
+/** Поддержанные корневые формы Type Source v1. */
+export type TypeSourceDefinition = TypeSourceObjectDefinition | TypeSourceEnumDefinition | TypeSourceUnionDefinition | TypeSourceArrayDefinition;
+/** Рекурсивное выражение типа: ссылка или анонимное inline-определение. */
+export type TypeSourceExpression = TypeSourceReference | TypeSourceDefinition;
+/** Canonical authoring document Type Source v1. */
+export interface TypeSourceDocument {
+    definition: TypeSourceDefinition;
+}
+/** Compiler payload Type Source. Runtime пока не потребляет этот artifact. */
+export interface TypeProgramPayload {
+    type: 'type';
+    sourceVersion: number;
+    /** Stable identity of the compiled type. Parser-only artifacts may omit it. */
+    identity?: string;
+    displayName?: string;
+    category?: 'primitive' | 'reference' | 'user';
+    definition: TypeSourceDefinition | null;
+    runtimeType?: string;
+    entityReference?: {
+        target: string;
+        storage: 'id' | 'identity';
+    };
+}
+/** Read-only projection used by editors and language tooling. */
+export interface TypeProgramCatalogEntry {
+    id: string | number;
+    identity: string;
+    displayName: string;
+    category: 'primitive' | 'reference' | 'user';
+    sourceVersion: number;
+    definition: TypeSourceDefinition | null;
+    runtimeType?: string;
+    entityReference?: TypeProgramPayload['entityReference'];
+    status: 'valid' | 'warning' | 'error';
+}
+/** Результат безопасного разбора Type Source. */
+export interface TypeSourceCompileResult {
+    ast: unknown | null;
+    document: TypeSourceDocument | null;
+    artifact: TypeProgramPayload | null;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+}

package/dist/domain/types/style/index.d.ts

@@ -0,0 +1 @@
+export * from './style.types';

package/dist/domain/types/style/style.types.d.ts

@@ -0,0 +1,202 @@
+export interface EndgeStyleSourceRange {
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export interface EndgeStyleDiagnostic {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+    range?: EndgeStyleSourceRange;
+}
+export interface EndgeStyleSpecificity {
+    ids: number;
+    classes: number;
+    types: number;
+}
+export type EndgeStyleCombinator = 'descendant' | 'child' | 'adjacent' | 'sibling';
+export type EndgeStyleAttributeOperator = 'exists' | '=' | '~=' | '|=' | '^=' | '$=' | '*=';
+export interface EndgeStyleAttributeSelector {
+    name: string;
+    operator: EndgeStyleAttributeOperator;
+    value?: string;
+    insensitive?: boolean;
+}
+export type EndgeStylePseudoSelector = {
+    name: 'first-child' | 'last-child';
+} | {
+    name: 'nth-child';
+    expression: string;
+} | {
+    name: 'component' | 'identity' | 'state';
+    value: string;
+} | {
+    name: 'not' | 'is' | 'where';
+    selectors: EndgeStyleSelector[];
+} | {
+    name: 'part';
+    value: string;
+    element: true;
+};
+export interface EndgeStyleCompoundSelector {
+    tag?: string;
+    universal?: boolean;
+    ids: string[];
+    classes: string[];
+    attributes: EndgeStyleAttributeSelector[];
+    pseudos: EndgeStylePseudoSelector[];
+}
+export interface EndgeStyleSelectorSegment {
+    combinator: EndgeStyleCombinator | null;
+    compound: EndgeStyleCompoundSelector;
+}
+/** Selector is stored left-to-right. The matcher evaluates it right-to-left. */
+export interface EndgeStyleSelector {
+    source: string;
+    segments: EndgeStyleSelectorSegment[];
+    specificity: EndgeStyleSpecificity;
+}
+export interface EndgeStyleValueToken {
+    type: 'word' | 'string' | 'space' | 'divider' | 'function' | 'comment';
+    value: string;
+    nodes?: EndgeStyleValueToken[];
+}
+export interface EndgeStyleDeclaration {
+    property: string;
+    value: string;
+    valueTokens: EndgeStyleValueToken[];
+    important: boolean;
+    range?: EndgeStyleSourceRange;
+}
+export type EndgeStyleSupportCondition = {
+    type: 'renderer';
+    renderer: string;
+} | {
+    type: 'capability';
+    capability: string;
+} | {
+    type: 'not';
+    operand: EndgeStyleSupportCondition;
+} | {
+    type: 'and' | 'or';
+    operands: EndgeStyleSupportCondition[];
+};
+export interface EndgeStyleScope {
+    root: EndgeStyleSelector[];
+    limit?: EndgeStyleSelector[];
+}
+export interface EndgeStyleRule {
+    id: string;
+    selectors: EndgeStyleSelector[];
+    declarations: EndgeStyleDeclaration[];
+    theme?: string;
+    scope?: EndgeStyleScope;
+    supports?: EndgeStyleSupportCondition;
+    sourceOrder: number;
+    range?: EndgeStyleSourceRange;
+}
+export interface EndgeStyleTheme {
+    id: string;
+    declarations: EndgeStyleDeclaration[];
+    range?: EndgeStyleSourceRange;
+}
+export interface EndgeStyleRuleIndex {
+    universal: string[];
+    tags: Record<string, string[]>;
+    classes: Record<string, string[]>;
+    ids: Record<string, string[]>;
+    components: Record<string, string[]>;
+    identities: Record<string, string[]>;
+    states: Record<string, string[]>;
+    parts: Record<string, string[]>;
+}
+export interface EndgeStyleSheetArtifact {
+    language: 'endgecss';
+    version: 1;
+    identity: string;
+    sourceHash: string;
+    scope: 'global' | 'component';
+    scopeId?: string;
+    rules: EndgeStyleRule[];
+    themes: EndgeStyleTheme[];
+    indexes: EndgeStyleRuleIndex;
+}
+export interface EndgeStyleAst {
+    type: 'stylesheet';
+    source: string;
+    nodes: unknown[];
+}
+export interface CompileEndgeCSSOptions {
+    identity?: string;
+    scope?: 'global' | 'component';
+    scopeId?: string;
+    maxNestedSelectors?: number;
+}
+export interface CompileEndgeCSSResult {
+    ast: EndgeStyleAst | null;
+    artifact: EndgeStyleSheetArtifact | null;
+    diagnostics: EndgeStyleDiagnostic[];
+}
+export interface EndgeStyleTargetProfile {
+    renderer: string;
+    capabilities?: Iterable<string>;
+}
+/** Renderer-neutral logical node. DOM wrappers are intentionally absent. */
+export interface EndgeStyleMatchNode {
+    tag: string;
+    id?: string;
+    classes: ReadonlySet<string>;
+    attributes: Readonly<Record<string, unknown>>;
+    states: ReadonlySet<string>;
+    parts: ReadonlySet<string>;
+    component?: string;
+    identity?: string;
+    ownerScopeId?: string;
+    /** Runtime lifecycle ancestry; used by renderer-neutral placement isolation. */
+    runtimeScopeIds?: ReadonlySet<string>;
+    parent?: EndgeStyleMatchNode;
+    /**
+     * Immediate logical predecessor. A linked chain keeps sibling combinators
+     * renderer-neutral without retaining a copied prefix for every node.
+     */
+    previousSibling?: EndgeStyleMatchNode;
+    index: number;
+    siblingCount: number;
+}
+export interface EndgeStyleResolvedDeclaration extends EndgeStyleDeclaration {
+    ruleId: string;
+    specificity: EndgeStyleSpecificity;
+    sourceOrder: number;
+}
+export interface EndgeStylePlacement {
+    id: string;
+    artifactIdentity: string;
+    artifact: EndgeStyleSheetArtifact;
+    ownerScopeIds: readonly string[];
+    boundaryId: string;
+    orderKey: string;
+    state: 'active' | 'suspended';
+    referenceCount: number;
+}
+export interface AcquireEndgeStyleOptions {
+    artifactIdentity?: string;
+    artifact?: EndgeStyleSheetArtifact;
+    ownerScopeId: string;
+    boundaryId: string;
+    orderKey?: string;
+}
+export interface EndgeStyleLease {
+    readonly id: string;
+    readonly kind: 'style';
+    readonly artifactIdentity: string;
+    readonly ownerScopeId: string;
+    readonly boundaryId: string;
+    readonly orderKey: string;
+    readonly suspended: boolean;
+    suspend: () => void;
+    resume: () => void;
+    release: () => void;
+    pause: () => void;
+    dispose: () => void;
+}

package/dist/domain/types/types.d.ts

@@ -1,57 +1,3 @@
-import { RComponentBase } from '../entities/reflect/RComponentBase';
-import { RuntimeScope } from '../entities/runtime/RuntimeScope';
-import { ElementNode } from '@vue/compiler-dom';
-import { VNode } from 'vue';
-import { RComponent } from './component.types';
-export declare enum RenderComponentType {
-    Functional = "functional",// функциональный компонент
-    Component = "component"
-}
-export interface RenderComponentInfo {
-    type: RenderComponentType;
-    component: any;
-}
-/**
- * Описывает UI оформление данных
- */
-export declare enum Prefix {
-    ComponentWrapper = "endge-component",
-    TooltipAttributeText = "endge-tooltip-text",
-    TooltipAttributeId = "endge-tooltip-id"
-}
-/**
- * Props для рендер-компонента
- */
-export interface ComponentType_Props<T extends RComponentBase> {
-    model: T;
-    comData: Record<string, any>;
-    scope: RuntimeScope;
-    context?: Record<string, any>;
-}
-/**
- * Входной тип для рендер-компонента (в частности h-функций)
- */
-export type ComponentRendererInput = ComponentType_Props<RComponent>;
-/**
- * Props для компонента JSX
- */
-export interface JSXComponentProps {
-    node: ElementNode;
-    children: (VNode | string | null)[];
-    scope: RuntimeScope;
-    handlers?: Record<string, CallableFunction>;
-    comData: Record<string, any>;
-    styles?: Record<string, string>;
-}
-/**
- * Входные данные для middleware-функции
- */
-export interface JSXRenderMiddlewareInput {
-    h: any;
-    props: JSXComponentProps;
-    node: ElementNode;
-    vnode: VNode | null;
-}
 /**
  * Модель для описания того, как извлекаются данные под некоторый входной тип
  */
@@ -72,17 +18,6 @@ export interface GQLQueryNode {
     children?: GQLQueryNode[];
     args?: Record<string, any>;
 }
-/**
- * Параметры для запуска сценария с настройками из панели тестирования.
- */
-export interface EndgeScenarioTestingOptions {
-    generatorCount?: number;
-    updatesPerSeconds?: number;
-    updatesOptions?: {
-        paths: Set<string>;
-        vars: Record<string, any>;
-    };
-}
 export interface EndgeGlobalVar {
     name: string;
     defaultValue: any;