@endge/core 5.0.0 → 7.0.0

package/dist/features/core/modules/domain/types/document/query.types.d.ts

@@ -0,0 +1,65 @@
+export type RQueryAuthMode = 'none' | 'inherit' | 'profile';
+export interface RQueryAuth {
+    mode: RQueryAuthMode;
+    /** Identity auth-profile для mode=profile. */
+    profile?: string;
+    /** Схема для заголовка (по умолчанию "Bearer"). */
+    scheme?: string;
+    /** Имя заголовка (по умолчанию "Authorization"). */
+    headerName?: string;
+    /**
+     * Куда класть токен: в заголовок или в query.
+     * По умолчанию 'header'.
+     */
+    sendAs?: 'header' | 'query';
+    /** Имя query-параметра (если sendAs='query', по умолчанию 'access_token'). */
+    queryParamName?: string;
+}
+/** Режим применения списка фильтров запроса (пока только слияние по порядку). */
+export type RQueryFilterApplyMode = 'merge';
+export type FilterFieldType = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'multi-select';
+export interface FilterStaticValue {
+    label: string;
+    value: string;
+}
+export interface FilterDynamicSource {
+    type: 'payload' | 'vocabs' | 'query';
+    collection?: string;
+    mapLabel?: string;
+    mapValue?: string;
+    queryIdentity?: string;
+}
+export interface FilterFieldSchema {
+    key: string;
+    label: string;
+    description?: string;
+    required?: boolean;
+    multiple?: boolean;
+    type: FilterFieldType;
+    staticValues?: FilterStaticValue[];
+    dynamicSource?: FilterDynamicSource | null;
+}
+export interface RuntimeFilterLink {
+    identity: string;
+    displayName: string;
+    description?: string;
+}
+/** Схема параметра (коллекция parameters в Payload). */
+export interface RParameterSchema {
+    identity: string;
+    displayName: string;
+    description?: string | null;
+    fields: FilterFieldSchema[];
+    runtimeFilters?: RuntimeFilterLink[];
+    folder?: string | null;
+    folderId?: string | number | null;
+    author?: string;
+    active: boolean;
+    deletedAt?: string | null;
+    meta?: Record<string, unknown>;
+}
+export declare class RuntimeFilterLinkEntity {
+    identity: string;
+    displayName: string;
+    description?: string;
+}

package/dist/features/core/modules/domain-repository/EndgeDomainRepository_Module.d.ts

@@ -0,0 +1,67 @@
+import { EndgeBootContext } from '../../kernel/types/bootstrap.types';
+import { DocumentCreateRequest, DocumentCreateResult } from '../domain/types/document/document-create.type';
+import { EndgeDomainDocumentMove } from '../domain/types/document/document-move.type';
+import { DomainDocumentType } from '../domain/types/document/document.types';
+import { EndgeDomainRepositoryCapabilities } from '../domain/types/document/domain-provider.type';
+import { EndgeDocumentServerState, EndgeLiveDomainSnapshot } from '../domain/types/document/domain-snapshot.type';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Явная ошибка записи через bundle/plain или live backend только для чтения. */
+export declare class EndgeDomainRepositoryReadOnlyError extends Error {
+    readonly code = "provider_read_only";
+    constructor(provider: string);
+}
+/** Граница persistence для live service-backend и локальных источников только для чтения. */
+export declare class EndgeDomainRepository_Module extends EndgeModule<EndgeBootContext> {
+    private _loadedSnapshot;
+    private _domainProvider;
+    private _domainETag;
+    private _documentServerState;
+    private _workspaceServerState;
+    private _capabilities;
+    get capabilities(): EndgeDomainRepositoryCapabilities;
+    get domainETag(): string | null;
+    get isHealthy(): boolean;
+    get hasErrors(): boolean;
+    setup(ctx: EndgeBootContext): Promise<void>;
+    /** Загружает live snapshot через активный transport provider и индексирует server state. */
+    loadSnapshot(ctx: EndgeBootContext): Promise<EndgeLiveDomainSnapshot>;
+    getLoadedSnapshot(): EndgeLiveDomainSnapshot | null;
+    getDocumentServerState(documentType: string, identity: string): EndgeDocumentServerState | null;
+    reset(): void;
+    isDocumentIdentityAvailable(documentType: DomainDocumentType, identity: string): Promise<boolean>;
+    createDocument(request: DocumentCreateRequest): Promise<DocumentCreateResult>;
+    saveDocument(documentId: string | number, documentType: DomainDocumentType, opts?: {
+        model?: unknown;
+        previousIdentity?: string;
+    }): Promise<void>;
+    deleteDocument(documentIdOrIdentity: string, documentType: DomainDocumentType): Promise<void>;
+    restoreDocument(documentIdOrIdentity: string, documentType: DomainDocumentType): Promise<void>;
+    changeDocumentFolder(documentId: string | number, documentType: DomainDocumentType, folderIdOrIdentity: string | number | null): Promise<void>;
+    /** Атомарно переносит несколько persisted-документов в одну папку. */
+    changeDocumentsFolder(documents: readonly EndgeDomainDocumentMove[], folderIdOrIdentity: string | number): Promise<number>;
+    saveFolder(folderId: string): Promise<void>;
+    deleteFolder(folderIdentity: string): Promise<void>;
+    restoreFolder(folderIdentity: string): Promise<void>;
+    toJSON(): Record<string, unknown>;
+    private _indexSnapshotServerState;
+    private _serverStateKey;
+    private _requireDocumentServerState;
+    private _findServerIdentity;
+    private _assertMutationsSupported;
+    private _serviceProvider;
+    private _requireServiceProvider;
+    private _serviceWorkspaceIdentity;
+    private _serviceFolderIds;
+    private _saveServiceDocument;
+    private _applyServiceDocument;
+    private _applyServiceFolder;
+    private _resolveDocumentIdentity;
+    private _getDomainDocumentByType;
+    private _removeDomainDocumentByType;
+    private _getDomainCollectionKey;
+    private _notifyDomainChanged;
+    /** Собирает явные lookup-зависимости чистой Domain-сериализации. */
+    private _serializationContext;
+    /** Сериализует persisted document через его канонический Domain descriptor. */
+    private _serializeDocument;
+}

package/dist/features/core/modules/domain-repository/services/domain-provider.d.ts

@@ -0,0 +1,10 @@
+import { DomainDocumentType } from '../../domain/types/document/document.types';
+import { EndgeDomainCollection } from '../../domain/types/document/domain-provider.type';
+export declare class EndgeProviderCollectionUnsupportedError extends Error {
+    readonly documentType: DomainDocumentType;
+    readonly code = "provider_collection_unsupported";
+    constructor(documentType: DomainDocumentType);
+}
+export declare function resolveEndgeServiceCollection(documentType: DomainDocumentType): EndgeDomainCollection;
+/** Принимает canonical collection либо Core document type для server-state lookup. */
+export declare function resolveEndgeServiceStateCollection(value: string): EndgeDomainCollection;

package/dist/features/core/modules/events/EndgeEvents_Module.d.ts

@@ -0,0 +1,72 @@
+import { EventCallback, OneOrMany } from '@endge/utils';
+import { CachedEvent, EndgeCoreEventMap, EndgeCustomEventMap, EndgeEmitOptions, EndgeEvent } from './domain/events.types';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/**
+ * Модуль событий Endge.
+ * Инкапсулирует core/custom event bus и небольшой runtime-кеш последних событий.
+ */
+export declare class EndgeEvents_Module extends EndgeModule {
+    static EVENTS_CACHE_SIZE: number;
+    private readonly _bus;
+    private _cache;
+    /**
+     * Создает event bus с заранее известными core-событиями.
+     */
+    constructor(predefinedEvents?: (keyof EndgeCoreEventMap & string)[]);
+    /**
+     * Изменяет размер кеша последних событий для текущего экземпляра.
+     */
+    setCacheSize(next: number): void;
+    /**
+     * Внутренний helper модуля: make Cache.
+     */
+    private _makeCache;
+    /**
+     * Возвращает текущую емкость кеша событий.
+     */
+    get cacheSize(): number;
+    /**
+     * Возвращает количество событий, сохраненных в кеше.
+     */
+    get cachedCount(): number;
+    /**
+     * Возвращает снимок кеша событий от старых к новым.
+     */
+    get lastEvents(): CachedEvent[];
+    /**
+     * Очищает кеш последних событий.
+     */
+    clearCache(): void;
+    /**
+     * Подписывает обработчик на типизированные core-события Endge.
+     */
+    onEvent<K extends keyof EndgeCoreEventMap & string>(events: OneOrMany<K>, callback: (e: EndgeEvent<EndgeCoreEventMap[K]>) => void): () => void;
+    /**
+     * Публикует типизированное core-событие Endge.
+     */
+    emitEvent<K extends keyof EndgeCoreEventMap & string>(event: K, payload: EndgeCoreEventMap[K], opts?: EndgeEmitOptions): EndgeEvent<EndgeCoreEventMap[K]>;
+    /**
+     * Подписывает обработчик на динамические пользовательские события.
+     */
+    onDynamic<K extends keyof EndgeCustomEventMap & string>(events: OneOrMany<K>, callback: (e: EndgeEvent<EndgeCustomEventMap[K]>) => void): () => void;
+    /**
+     * Публикует динамическое пользовательское событие.
+     */
+    emitDynamic<K extends keyof EndgeCustomEventMap & string>(event: K, payload: EndgeCustomEventMap[K], opts?: EndgeEmitOptions): EndgeEvent<EndgeCustomEventMap[K]>;
+    /**
+     * Подписывает raw-callback на core-события без обертки EndgeEvent.
+     */
+    on<K extends keyof EndgeCoreEventMap & string>(events: OneOrMany<K>, callback: EventCallback<EndgeCoreEventMap[K]>): void;
+    /**
+     * Снимает raw-callback с core-событий.
+     */
+    off<K extends keyof EndgeCoreEventMap & string>(events: OneOrMany<K>, callback: EventCallback<EndgeCoreEventMap[K]>): void;
+    /**
+     * Подписывает raw-callback на пользовательские события.
+     */
+    onCustom<K extends keyof EndgeCustomEventMap & string>(events: OneOrMany<K>, callback: EventCallback<EndgeCustomEventMap[K]>): void;
+    /**
+     * Снимает raw-callback с пользовательских событий.
+     */
+    offCustom<K extends keyof EndgeCustomEventMap & string>(events: OneOrMany<K>, callback: EventCallback<EndgeCustomEventMap[K]>): void;
+}

package/dist/features/core/modules/i18n/EndgeI18n_Module.d.ts

@@ -0,0 +1,88 @@
+import { I18nLocaleMessages, I18nMessagesOptions, I18nRuntimeCatalog, I18nTranslateOptions } from './domain/i18n.types';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/**
+ * Runtime-доступ к доменным словарям переводов.
+ */
+export declare class EndgeI18n_Module extends EndgeModule {
+    private _fallbackLocale;
+    private _offContext;
+    private _offDomain;
+    private _lastLocale;
+    private readonly _messagesByLocale;
+    private readonly _messagesByBundle;
+    /**
+     * Подписывается на контекст, чтобы подписчики i18n тоже реагировали на смену locale.
+     */
+    setup(): void;
+    /**
+     * Компилирует активные i18n-bundles в плоские индексы для O(1) lookup.
+     */
+    build(): void;
+    /**
+     * Очищает подписку на контекст.
+     */
+    reset(): void;
+    /**
+     * Текущая локаль переводов.
+     */
+    get locale(): string;
+    /**
+     * Локаль fallback, если ключ отсутствует в текущей локали.
+     */
+    get fallbackLocale(): string;
+    /**
+     * Задает текущую локаль.
+     */
+    setLocale(locale: string): void;
+    /**
+     * Задает fallback-локаль.
+     */
+    setFallbackLocale(locale: string): void;
+    /**
+     * Пересобирает индексы переводов из активных i18n-bundles.
+     */
+    rebuildIndexes(): void;
+    /**
+     * Переводит ключ из активных i18n-bundles.
+     */
+    t(key: string, options?: I18nTranslateOptions | string): string;
+    /**
+     * Разрешает `alias:key.path` только в переданном Composition catalog.
+     * Физический identity i18n-документа не является частью публичного ключа.
+     */
+    translate(catalog: I18nRuntimeCatalog, key: string, fallback?: string): string;
+    /**
+     * Проверяет, существует ли перевод для ключа.
+     */
+    te(key: string, options?: I18nTranslateOptions | string): boolean;
+    /**
+     * Возвращает значение перевода без приведения к строке.
+     */
+    resolve(key: string, options?: I18nTranslateOptions | string): unknown;
+    /**
+     * Собирает сообщения активных словарей для указанной локали.
+     */
+    getMessages(locale?: string, options?: I18nMessagesOptions): I18nLocaleMessages;
+    /** Нормализует сокращённые и полные options перевода. */
+    private _normalizeOptions;
+    /** Разбирает ключ формата `bundle:key`. */
+    private _parseKey;
+    /** Ищет перевод в общем или bundle-specific index. */
+    private _resolveFromIndex;
+    /** Возвращает доступные translation bundles. */
+    private _getBundles;
+    /** Читает сообщения locale из одного bundle. */
+    private _readLocaleMessages;
+    /** Подставляет параметры в placeholders строки перевода. */
+    private _interpolate;
+    /** Рекурсивно объединяет деревья сообщений. */
+    private _mergeMessages;
+    /** Возвращает или создаёт общий index для locale. */
+    private _getLocaleIndex;
+    /** Возвращает или создаёт index locale для конкретного bundle. */
+    private _getBundleLocaleIndex;
+    /** Записывает вложенные сообщения в плоский dot-path index. */
+    private _writeMessagesIndex;
+    /** Проверяет, является ли значение обычным object. */
+    private _isPlainObject;
+}

package/dist/features/core/modules/i18n/domain/i18n.types.d.ts

@@ -0,0 +1,25 @@
+export type I18nLocaleMessages = Record<string, unknown>;
+export type I18nLocales = Record<string, I18nLocaleMessages>;
+/** Плоский compiler-derived индекс сообщений одной локали. */
+export type I18nCompiledLocaleMessages = Record<string, string>;
+/** Compiler-derived сообщения одного i18n-документа по локалям. */
+export type I18nCompiledLocales = Record<string, I18nCompiledLocaleMessages>;
+/** Один публичный translation alias в runtime-контексте Composition. */
+export interface I18nRuntimeCatalogEntry {
+    messages: I18nCompiledLocales;
+}
+/** Накопленный translation catalog, доступный дочернему runtime. */
+export type I18nRuntimeCatalog = Record<string, I18nRuntimeCatalogEntry>;
+/** Происхождение только для authoring: публичный alias -> локаль -> ключ сообщения -> идентификатор документа. */
+export type I18nCatalogProvenance = Record<string, Record<string, Record<string, string>>>;
+export interface I18nTranslateOptions {
+    locale?: string;
+    fallbackLocale?: string;
+    bundle?: string;
+    params?: Record<string, unknown>;
+    defaultValue?: string;
+}
+export interface I18nMessagesOptions {
+    bundle?: string;
+    includeInactive?: boolean;
+}

package/dist/features/core/modules/i18n/services/composition-i18n-catalog-projection.d.ts

@@ -0,0 +1,19 @@
+import { I18nCatalogProvenance, I18nRuntimeCatalog } from '../domain/i18n.types';
+import { RuntimeArtifactReader } from '../../runtime/domain/runtime-host.types';
+export interface CompositionI18nCatalogProjectionOccurrence {
+    id: string;
+    rootIdentity: string;
+    invocationPath: string[];
+    catalogsByScope: Readonly<Record<string, I18nRuntimeCatalog>>;
+    provenanceByScope: Readonly<Record<string, I18nCatalogProvenance>>;
+}
+export interface CompositionI18nCatalogProjectionInput {
+    artifacts: RuntimeArtifactReader;
+    rootIdentities: readonly string[];
+    targetIdentity: string;
+}
+/**
+ * Проецирует фактические каталоги i18n только из скомпилированных артефактов Composition.
+ * RuntimeHost, lifecycle-хуки и пользовательский runtime source не выполняются.
+ */
+export declare function projectCompositionI18nCatalogs(input: CompositionI18nCatalogProjectionInput): CompositionI18nCatalogProjectionOccurrence[];

package/dist/features/core/modules/i18n/services/i18n-catalog.d.ts

@@ -0,0 +1,12 @@
+import { I18nCompiledLocales, I18nLocales, I18nRuntimeCatalog } from '../domain/i18n.types';
+import { CompositionI18nResourceArtifact, CompositionProgramPayload } from '../../source/domain/types/composition-source.types';
+/** Материализует authored locale trees в плоские dot-path индексы. */
+export declare function compileI18nLocales(locales: I18nLocales): I18nCompiledLocales;
+/** Возвращает все логические message keys независимо от локали. */
+export declare function collectI18nMessageKeys(messages: I18nCompiledLocales): Set<string>;
+/** Добавляет локальные ресурсы scope к унаследованному runtime catalog. */
+export declare function extendI18nRuntimeCatalog(inherited: I18nRuntimeCatalog, resources: readonly CompositionI18nResourceArtifact[]): I18nRuntimeCatalog;
+/** Строит effective translation catalogs всех lifecycle scopes Composition. */
+export declare function buildCompositionI18nCatalogs(payload: CompositionProgramPayload, inherited?: I18nRuntimeCatalog): Map<string, I18nRuntimeCatalog>;
+/** Создаёт независимый snapshot runtime catalog для передачи дочернему host. */
+export declare function cloneI18nRuntimeCatalog(catalog: I18nRuntimeCatalog): I18nRuntimeCatalog;

package/dist/features/core/modules/implementations/EndgeImplementations_Module.d.ts

@@ -0,0 +1,36 @@
+import { ImplementationBinding, ImplementationInvocation, ImplementationProvider, ImplementationResolutionRequest, ImplementationSnapshot, ResolvedImplementation } from './domain/implementation.types';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Общий runtime-модуль для провайдеров кода, bindings и фактического разрешения. */
+export declare class EndgeImplementations_Module extends EndgeModule {
+    private readonly _providers;
+    private readonly _bindings;
+    /**
+     * ----------------------------------------
+     * PUBLIC
+     * ----------------------------------------
+     */
+    /** Регистрирует локальный исполняемый код и возвращает его disposer. */
+    registerProvider(provider: ImplementationProvider): () => void;
+    hasProvider(key: string): boolean;
+    /** Регистрирует явный binding и возвращает его disposer. */
+    bind(binding: ImplementationBinding): () => void;
+    /** Определяет фактический провайдер по scope и приоритету. */
+    resolve(request: ImplementationResolutionRequest): ResolvedImplementation;
+    /** Возвращает null только когда не объявлены ни binding, ни provider по умолчанию. */
+    resolveOptional(request: ImplementationResolutionRequest): ResolvedImplementation | null;
+    /** Вычисляет и выполняет один вызов через его фактический provider. */
+    execute<TResult = unknown>(request: ImplementationResolutionRequest, invocation: ImplementationInvocation): Promise<TResult>;
+    /** Включает безопасную проекцию implementations в диагностическое дерево. */
+    createDiagnosticsSnapshot(): ImplementationSnapshot;
+    /** Возвращает сериализуемый snapshot инспекции без функций. */
+    snapshot(): ImplementationSnapshot;
+    /** Освобождает providers и bindings после зависимых execution Modules. */
+    reset(): void;
+    /**
+     * ----------------------------------------
+     * PRIVATE
+     * ----------------------------------------
+     */
+    private _requireProvider;
+    private _assertCompatibleContract;
+}

package/dist/features/core/modules/implementations/domain/implementation.types.d.ts

@@ -0,0 +1,59 @@
+import { ActionExecutionTarget, ActionTargetSelector, ImplementationBindingScope } from '../../actions/domain/action.types';
+import { EntityOrigin } from '../../domain/types/document/entity-management.type';
+export interface ImplementationContract {
+    target?: ActionTargetSelector[] | null;
+    input?: unknown | null;
+    output?: unknown | null;
+}
+export interface ImplementationExecutableRef {
+    type: string;
+    identity: string;
+    value?: unknown;
+}
+export interface ImplementationInvocation<TInput = unknown> {
+    executable: ImplementationExecutableRef;
+    input?: TInput;
+    target?: ActionExecutionTarget;
+    context?: Record<string, unknown>;
+}
+export interface ImplementationProvider<TInput = unknown, TResult = unknown> {
+    key: string;
+    origin: EntityOrigin;
+    active?: boolean;
+    contract?: ImplementationContract;
+    canExecute?: (invocation: ImplementationInvocation<TInput>) => boolean;
+    execute: (invocation: ImplementationInvocation<TInput>) => TResult | Promise<TResult>;
+}
+export interface ImplementationBinding {
+    executableType: string;
+    executableIdentity: string;
+    providerKey: string;
+    scope: Exclude<ImplementationBindingScope, 'default'>;
+    scopeIdentity?: string;
+    priority?: number;
+}
+export interface ImplementationResolutionRequest {
+    executable: ImplementationExecutableRef;
+    defaultProviderKey: string | null;
+    scopeIdentities?: Partial<Record<Exclude<ImplementationBindingScope, 'default'>, string>>;
+    invocationProviderKey?: string;
+    expectedContract?: ImplementationContract;
+}
+export interface ResolvedImplementation {
+    provider: ImplementationProvider;
+    binding: ImplementationBinding | null;
+    scope: ImplementationBindingScope;
+}
+export interface ImplementationSnapshot {
+    providers: Array<{
+        key: string;
+        active: boolean;
+        origin: EntityOrigin;
+    }>;
+    bindings: ImplementationBinding[];
+}
+export type ImplementationDiagnosticCode = 'implementation-provider-missing' | 'implementation-provider-inactive' | 'implementation-binding-ambiguous' | 'implementation-cannot-execute' | 'implementation-contract-incompatible';
+export declare class ImplementationError extends Error {
+    readonly code: ImplementationDiagnosticCode;
+    constructor(code: ImplementationDiagnosticCode, message: string);
+}

package/dist/features/core/modules/implementations/services/ImplementationBindingRegistry.d.ts

@@ -0,0 +1,9 @@
+import { ImplementationBinding, ImplementationResolutionRequest } from '../domain/implementation.types';
+/** Разрешает явные bindings без зависимости от порядка регистрации. */
+export declare class ImplementationBindingRegistry {
+    private readonly _bindings;
+    register(binding: ImplementationBinding): () => void;
+    resolve(request: ImplementationResolutionRequest): ImplementationBinding | null;
+    list(): ImplementationBinding[];
+    clear(): void;
+}

package/dist/features/core/modules/implementations/services/ImplementationProviderRegistry.d.ts

@@ -0,0 +1,9 @@
+import { ImplementationProvider } from '../domain/implementation.types';
+/** Владеет исполняемыми функциями провайдеров; провайдеры никогда не сохраняются. */
+export declare class ImplementationProviderRegistry {
+    private readonly _providers;
+    register(provider: ImplementationProvider): () => void;
+    get(key: string): ImplementationProvider | null;
+    list(): ImplementationProvider[];
+    clear(): void;
+}

package/dist/features/core/modules/mock/EndgeMock_Module.d.ts

@@ -0,0 +1,29 @@
+import { EndgeMockBindingStatus, EndgeMockDescriptor, EndgeMockProvider, EndgeMockRegistration, EndgeMockSnapshot } from './domain/types/mock-data.type';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Runtime resolver persisted mock-документов и подключенных code providers. */
+export declare class EndgeMock_Module extends EndgeModule {
+    private readonly _providers;
+    /** Создает пустой registry для application providers. */
+    constructor();
+    /** Регистрирует provider по namespaced ref и запрещает неявную замену. */
+    registerProvider(provider: EndgeMockProvider): void;
+    /**
+     * Compatibility adapter старого data registration.
+     * Он регистрирует только provider и не создает RMock в домене.
+     */
+    register(registration: EndgeMockRegistration): void;
+    /** Возвращает состояние binding persisted mock и code provider. */
+    getBindingStatus(identity: string): EndgeMockBindingStatus;
+    /** Проверяет, может ли persisted mock быть разрешен прямо сейчас. */
+    has(identity: string): boolean;
+    /** Разрешает данные из persisted document или его code provider. */
+    get<T = unknown>(identity: string): T;
+    /** Возвращает descriptions зарегистрированных code providers. */
+    listProviders(): EndgeMockDescriptor[];
+    /** @deprecated Используйте listProviders(). */
+    list(): EndgeMockDescriptor[];
+    /** Очищает runtime providers. */
+    reset(): void;
+    /** Возвращает легкий snapshot provider registry. */
+    serialize(): EndgeMockSnapshot;
+}

package/dist/features/core/modules/mock/domain/types/mock-data.type.d.ts

@@ -0,0 +1,37 @@
+import { RMock } from '../../../domain/entities/RMock';
+export type RMockContentSource = 'document' | 'code-provider';
+export type RMockContentType = 'application/json' | 'text/plain';
+/** Контекст вызова code provider для persisted mock-документа. */
+export interface EndgeMockProviderContext {
+    mock: RMock;
+}
+/** Кодовая реализация содержимого, подключаемая к persisted mock по codeRef. */
+export interface EndgeMockProvider {
+    ref: string;
+    description?: string;
+    provide: (context: EndgeMockProviderContext) => unknown;
+}
+/** @deprecated Используйте EndgeMockProvider. */
+export interface EndgeMockRegistration {
+    /** Стабильный identity, используемый в source через mock(identity). */
+    identity: string;
+    /** Исходный mock payload. EndgeMock_Module хранит и возвращает независимые копии. */
+    data: unknown;
+    /** Необязательное описание сценария для diagnostics и configurator UI. */
+    description?: string;
+}
+/** Публичное описание зарегистрированного mock payload без самих данных. */
+export interface EndgeMockDescriptor {
+    ref: string;
+    description?: string;
+}
+export type EndgeMockBindingStatus = 'document' | 'connected' | 'missing-document' | 'missing-provider' | 'invalid-content';
+/** Сериализуемый snapshot модуля EndgeMock_Module. */
+export interface EndgeMockSnapshot {
+    providers: EndgeMockDescriptor[];
+}
+/** Compiler/runtime reference на mock payload. */
+export interface EndgeMockReference {
+    kind: 'mock';
+    identity: string;
+}