cs-element/dist/workers/types/typed-elements-interfaces.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

/**
 * Интерфейсы для системы типизированных элементов
 */
import { ICSElement, ValidationRule, ValidationResult } from './interfaces';
/**
 * Схема типизированного элемента
 */
export interface TypedElementSchema<T = any> {
    name: string;
    version: string;
    description?: string;
    fields: TypedFieldSchema<T>[];
    validationRules?: ValidationRule[];
    inheritFrom?: string;
    abstract?: boolean;
    sealed?: boolean;
    metadata?: Record<string, any>;
}
/**
 * Схема поля типизированного элемента
 */
export interface TypedFieldSchema<T = any> {
    name: keyof T;
    type: FieldType;
    required?: boolean;
    defaultValue?: any;
    description?: string;
    validation?: FieldValidation;
    metadata?: Record<string, any>;
}
/**
 * Типы полей
 */
export type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object' | 'reference' | 'computed' | 'enum' | 'union' | 'generic';
/**
 * Валидация поля
 */
export interface FieldValidation {
    min?: number;
    max?: number;
    pattern?: string;
    enum?: any[];
    custom?: (value: any) => boolean | string;
    required?: boolean;
    nullable?: boolean;
}
/**
 * Интерфейс типизированного элемента
 */
export interface ITypedElement<T = any> extends ICSElement {
    readonly typeName: string;
    readonly schema: TypedElementSchema<T>;
    readonly isAbstract: boolean;
    readonly isSealed: boolean;
    readonly inheritanceChain: string[];
    getTypedData(): Partial<T>;
    setTypedData(data: Partial<T>): Promise<void>;
    getField<K extends keyof T>(fieldName: K): T[K] | undefined;
    setField<K extends keyof T>(fieldName: K, value: T[K]): Promise<void>;
    validateType(): Promise<TypedValidationResult>;
    validateField<K extends keyof T>(fieldName: K, value: T[K]): Promise<FieldValidationResult>;
    canInheritFrom(typeName: string): boolean;
    getInheritedFields(): TypedFieldSchema<T>[];
    isInstanceOf(typeName: string): boolean;
    implementsInterface(interfaceName: string): boolean;
    getInheritanceMetadata(): {
        parentType: string | null;
        implementedInterfaces: string[];
        inheritanceDepth: number;
        isComposite: boolean;
        sourceSchemas?: string[];
    };
    serializeTyped(): SerializedTypedElement<T>;
    cloneTyped(): Promise<ITypedElement<T>>;
}
/**
 * Результат валидации типизированного элемента
 */
export interface TypedValidationResult extends ValidationResult {
    fieldErrors: Map<string, FieldValidationResult>;
    schemaErrors: string[];
    inheritanceErrors: string[];
}
/**
 * Результат валидации поля
 */
export interface FieldValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    fieldName: string;
    value: any;
    expectedType: FieldType;
    actualType: string;
}
/**
 * Сериализованный типизированный элемент
 */
export interface SerializedTypedElement<T = any> {
    id: string;
    name: string;
    typeName: string;
    schema: TypedElementSchema<T>;
    typedData: Partial<T>;
    rawData: Record<string, any>;
    metadata: {
        createdAt: number;
        updatedAt: number;
        version: string;
        inheritanceChain: string[];
    };
}
/**
 * Менеджер типизированных элементов
 */
export interface ITypedElementManager {
    registerSchema<T>(schema: TypedElementSchema<T>): void;
    unregisterSchema(typeName: string): void;
    getSchema<T>(typeName: string): TypedElementSchema<T> | null;
    getAllSchemas(): Map<string, TypedElementSchema>;
    createElement<T>(typeName: string, data?: Partial<T>): Promise<ITypedElement<T>>;
    createFromSchema<T>(schema: TypedElementSchema<T>, data?: Partial<T>): Promise<ITypedElement<T>>;
    validateSchema<T>(schema: TypedElementSchema<T>): SchemaValidationResult;
    validateInheritance(typeName: string, parentTypeName: string): boolean;
    findElementsByType<T>(typeName: string): ITypedElement<T>[];
    findElementsByField<T>(fieldName: keyof T, value: T[keyof T]): ITypedElement<T>[];
    buildInheritanceChain(typeName: string): string[];
    canInherit(childType: string, parentType: string): boolean;
    getTypeStats(): TypeStats;
}
/**
 * Результат валидации схемы
 */
export interface SchemaValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    conflictingFields: string[];
    missingDependencies: string[];
}
/**
 * Статистика типов
 */
export interface TypeStats {
    totalTypes: number;
    totalElements: number;
    typeDistribution: Map<string, number>;
    inheritanceDepth: Map<string, number>;
    validationErrors: number;
    mostUsedTypes: Array<{
        typeName: string;
        count: number;
    }>;
}
/**
 * Конфигурация типизированных элементов
 */
export interface TypedElementConfig {
    strictMode: boolean;
    autoValidation: boolean;
    allowDynamicFields: boolean;
    inheritanceEnabled: boolean;
    maxInheritanceDepth: number;
    cacheSchemas: boolean;
    defaultFieldValidation: FieldValidation;
}
/**
 * Фабрика типизированных элементов
 */
export interface ITypedElementFactory {
    create<T>(typeName: string, data?: Partial<T>): Promise<ITypedElement<T>>;
    createBatch<T>(typeName: string, dataArray: Partial<T>[]): Promise<ITypedElement<T>[]>;
    createFromTemplate<T>(templateName: string, data?: Partial<T>): Promise<ITypedElement<T>>;
    clone<T>(element: ITypedElement<T>): Promise<ITypedElement<T>>;
}
/**
 * Декоратор для типизированных элементов
 */
export interface TypedElementDecorator<T = any> {
    name: string;
    apply(element: ITypedElement<T>): Promise<void>;
    remove(element: ITypedElement<T>): Promise<void>;
    canApply(element: ITypedElement<T>): boolean;
}
/**
 * Событие типизированного элемента
 */
export interface TypedElementEvent<T = any> {
    type: TypedElementEventType;
    element: ITypedElement<T>;
    fieldName?: keyof T;
    oldValue?: any;
    newValue?: any;
    validationResult?: TypedValidationResult;
    timestamp: number;
}
/**
 * Типы событий типизированных элементов
 */
export declare enum TypedElementEventType {
    TypedDataChanged = "typed:data:changed",
    FieldChanged = "typed:field:changed",
    ValidationFailed = "typed:validation:failed",
    ValidationPassed = "typed:validation:passed",
    SchemaChanged = "typed:schema:changed",
    InheritanceChanged = "typed:inheritance:changed"
}
/**
 * Миксин для расширения функциональности
 */
export interface TypedElementMixin<T = any> {
    name: string;
    methods: Record<string, Function>;
    properties: Record<string, any>;
    lifecycle?: {
        beforeCreate?: (element: ITypedElement<T>) => Promise<void>;
        afterCreate?: (element: ITypedElement<T>) => Promise<void>;
        beforeValidate?: (element: ITypedElement<T>) => Promise<void>;
        afterValidate?: (element: ITypedElement<T>, result: TypedValidationResult) => Promise<void>;
    };
}
//# sourceMappingURL=typed-elements-interfaces.d.ts.map