@notty/types 0.6.0 → 0.14.0

package/dist/index.d.ts

@@ -69,7 +69,7 @@ interface ThemeConfig {
  * Allowed media types for media field
  */
 type MediaType = 'images' | 'videos' | 'audios' | 'files';
-type FieldType = 'string' | 'text' | 'richtext' | 'integer' | 'bigint' | 'decimal' | 'boolean' | 'date' | 'datetime' | 'json' | 'enum' | 'relation' | 'component' | 'media';
+type FieldType = 'string' | 'text' | 'richtext' | 'integer' | 'bigint' | 'decimal' | 'boolean' | 'date' | 'datetime' | 'json' | 'enum' | 'relation' | 'component' | 'dynamicZone' | 'media';
 interface ACmsField {
     type: FieldType;
     required?: boolean;
@@ -87,6 +87,7 @@ interface ACmsField {
     onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
     component?: string;
     repeatable?: boolean;
+    components?: string[];
     allowedTypes?: MediaType[];
     multiple?: boolean;
     index?: boolean | 'unique' | 'fulltext';
@@ -96,9 +97,44 @@ interface ACmsField {
         onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
         onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
     };
+    pluginOptions?: {
+        i18n?: {
+            localized: boolean;
+        };
+    };
 }
+/**
+ * Component Schema - переиспользуемая схема для встраиваемых компонентов
+ * Компоненты группируются по категориям и идентифицируются как 'category.name'
+ */
+interface ComponentSchema {
+    /**
+     * Уникальное имя в формате 'category.name'
+     * Примеры: 'shared.seo-meta', 'blocks.hero-section', 'ui.button'
+     */
+    uid: string;
+    /**
+     * Категория компонента (первая часть uid)
+     * Используется для группировки в UI
+     */
+    category: string;
+    info: {
+        displayName: string;
+        description?: string;
+        icon?: string;
+    };
+    /**
+     * Атрибуты компонента - те же типы полей, что и для ACmsSchema
+     * Компоненты могут содержать nested components, но не dynamicZone
+     */
+    attributes: Record<string, ACmsField>;
+}
+/**
+ * Content type schema kinds
+ */
+type SchemaKind = 'collectionType' | 'singleType';
 interface ACmsSchema {
-    kind: 'collectionType' | 'singleType';
+    kind: SchemaKind;
     info: {
         singularName: string;
         pluralName: string;
@@ -109,6 +145,11 @@ interface ACmsSchema {
         draftAndPublish?: boolean;
         timestamps?: boolean;
         softDelete?: boolean;
+        i18n?: {
+            enabled: boolean;
+            locales?: string[];
+            defaultLocale?: string;
+        };
     };
     attributes: Record<string, ACmsField>;
     indexes?: Array<{
@@ -118,7 +159,71 @@ interface ACmsSchema {
     }>;
 }
 /**
- * Пример схемы в универсальном формате
+ * Базовый тип для данных компонента при создании (без id)
+ */
+interface ComponentDataInput {
+    [key: string]: unknown;
+}
+/**
+ * Базовый тип для данных компонента в ответе (с id)
+ */
+interface ComponentData {
+    /**
+     * Optional id (may be absent for JSON-embedded storage)
+     */
+    id?: number;
+    [key: string]: unknown;
+}
+/**
+ * Элемент dynamic zone при создании - содержит тип компонента
+ */
+interface DynamicZoneItemInput {
+    __component: string;
+    [key: string]: unknown;
+}
+/**
+ * Элемент dynamic zone в ответе - содержит id и тип компонента
+ */
+interface DynamicZoneItem {
+    /**
+     * Optional id (may be absent for JSON-embedded storage)
+     */
+    id?: number;
+    __component: string;
+    [key: string]: unknown;
+}
+/**
+ * Данные поля component при создании
+ * Single: объект ComponentDataInput
+ * Repeatable: массив ComponentDataInput[]
+ */
+type ComponentFieldInput = ComponentDataInput | ComponentDataInput[];
+/**
+ * Данные поля component в ответе
+ * Single: объект ComponentData или null
+ * Repeatable: массив ComponentData[]
+ */
+type ComponentFieldData = ComponentData | ComponentData[] | null;
+/**
+ * Данные поля dynamicZone при создании
+ * Всегда массив элементов с __component
+ */
+type DynamicZoneInput = DynamicZoneItemInput[];
+/**
+ * Данные поля dynamicZone в ответе
+ * Всегда массив элементов с id и __component
+ */
+type DynamicZoneData = DynamicZoneItem[];
+/**
+ * Пример схемы компонента SEO Meta
+ */
+declare const exampleComponentSchema: ComponentSchema;
+/**
+ * Пример схемы блока для dynamic zone
+ */
+declare const exampleBlockComponent: ComponentSchema;
+/**
+ * Пример схемы в универсальном формате с компонентами и dynamic zone
  */
 declare const exampleSchema: ACmsSchema;
 
@@ -131,7 +236,7 @@ interface ValidationError {
     code: ValidationErrorCode;
     details?: unknown;
 }
-type ValidationErrorCode = 'MISSING_REQUIRED_FIELD' | 'INVALID_FIELD_TYPE' | 'INVALID_RELATION_TYPE' | 'DUPLICATE_FIELD_NAME' | 'INVALID_CONSTRAINT' | 'INVALID_ENUM_VALUES' | 'INVALID_RELATION_TARGET' | 'INVALID_RELATION_INVERSE' | 'MISSING_INFO' | 'EMPTY_ATTRIBUTES' | 'INVALID_MIN_MAX' | 'INVALID_LENGTH_CONSTRAINT' | 'INVALID_INDEX_TYPE' | 'INVALID_FOREIGN_KEY' | 'INVALID_INDEX_FIELDS';
+type ValidationErrorCode = 'MISSING_REQUIRED_FIELD' | 'INVALID_FIELD_TYPE' | 'INVALID_RELATION_TYPE' | 'DUPLICATE_FIELD_NAME' | 'INVALID_CONSTRAINT' | 'INVALID_ENUM_VALUES' | 'INVALID_RELATION_TARGET' | 'INVALID_RELATION_INVERSE' | 'MISSING_INFO' | 'EMPTY_ATTRIBUTES' | 'INVALID_MIN_MAX' | 'INVALID_LENGTH_CONSTRAINT' | 'INVALID_INDEX_TYPE' | 'INVALID_FOREIGN_KEY' | 'INVALID_INDEX_FIELDS' | 'INVALID_LOCALE_CODE' | 'INVALID_DEFAULT_LOCALE' | 'INVALID_COMPONENT_NAME' | 'INVALID_COMPONENT_UID' | 'COMPONENT_NOT_FOUND' | 'COMPONENT_CIRCULAR_REFERENCE' | 'COMPONENT_NESTED_DYNAMIC_ZONE' | 'INVALID_DYNAMIC_ZONE_COMPONENTS' | 'DYNAMIC_ZONE_EMPTY_COMPONENTS' | 'DYNAMIC_ZONE_COMPONENT_NOT_FOUND' | 'INVALID_COMPONENT_DATA' | 'MISSING_COMPONENT_TYPE' | 'COMPONENT_MIN_ITEMS' | 'COMPONENT_MAX_ITEMS';
 interface ValidationResult {
     valid: boolean;
     errors: ValidationError[];
@@ -227,4 +332,1073 @@ interface RollbackResult {
     errors?: string[];
 }
 
-export { type ACmsField, type ACmsSchema, type ContentEntry, type FieldType, type MediaType, type Migration, type MigrationDatabaseConnection, type MigrationRecord, type MigrationResult, type MigrationStatus, type MySQLMigrationConnection, type Plugin, type PluginHooks, type PostgresMigrationConnection, type QueryOptions, type RollbackResult, type SQLiteMigrationConnection, SchemaValidationError, type Theme, type ThemeConfig, type User, type ValidationError, type ValidationErrorCode, type ValidationResult, exampleSchema };
+/**
+ * Middleware Types
+ * Типы для системы middleware/хуков Notty CMS
+ */
+/**
+ * Метаданные выполнения запроса для трассировки
+ */
+interface RequestMeta {
+    /** Уникальный ID запроса (UUID) */
+    requestId: string;
+    /** ID трассировки (для распределённой трассировки) */
+    traceId?: string;
+    /** ID родительского span (для вложенных операций) */
+    parentSpanId?: string;
+    /** Timestamp начала запроса */
+    startTime: number;
+}
+/**
+ * Результат выполнения одного middleware с таймингами
+ */
+interface MiddlewareTiming {
+    /** Имя middleware */
+    name: string;
+    /** Время начала (performance.now или Date.now) */
+    startTime: number;
+    /** Время окончания */
+    endTime: number;
+    /** Длительность в мс */
+    duration: number;
+    /** Была ли ошибка */
+    error?: boolean;
+    /** Был ли прерван (continue: false) */
+    aborted?: boolean;
+}
+/**
+ * Агрегированный результат выполнения цепочки middleware
+ */
+interface MiddlewareChainResult<T = unknown> {
+    /** Результат выполнения */
+    result: T;
+    /** Тайминги по каждому middleware */
+    timings: MiddlewareTiming[];
+    /** Общее время выполнения цепочки */
+    totalDuration: number;
+    /** Количество выполненных middleware */
+    middlewaresExecuted: number;
+    /** ID запроса */
+    requestId: string;
+    /** Была ли ошибка */
+    hasError: boolean;
+    /** Была ли цепочка прервана */
+    wasAborted: boolean;
+}
+/**
+ * Унифицированный payload ошибки middleware
+ */
+interface MiddlewareError {
+    /** Имя middleware где произошла ошибка */
+    middlewareName: string;
+    /** Тип middleware */
+    middlewareType: 'admin' | 'content' | 'system';
+    /** Сообщение ошибки */
+    message: string;
+    /** Стек ошибки (опционально, в dev mode) */
+    stack?: string;
+    /** Код ошибки (если есть) */
+    code?: string;
+    /** HTTP статус (если применимо) */
+    statusCode?: number;
+    /** Timestamp ошибки */
+    timestamp: Date;
+    /** Request ID */
+    requestId: string;
+    /** Дополнительные данные */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Callback для логирования/метрик
+ */
+type MiddlewareObserver = {
+    /** Вызывается при завершении цепочки middleware */
+    onChainComplete?: (result: MiddlewareChainResult) => void;
+    /** Вызывается при ошибке в middleware */
+    onMiddlewareError?: (error: MiddlewareError) => void;
+    /** Вызывается при завершении одного middleware */
+    onMiddlewareComplete?: (timing: MiddlewareTiming, requestId: string) => void;
+};
+/**
+ * Базовый контекст запроса
+ */
+interface MiddlewareBaseContext {
+    /** URL path */
+    path: string;
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+    /** Request headers */
+    headers: Record<string, string | string[] | undefined>;
+    /** URL query parameters */
+    query: Record<string, string | string[] | undefined>;
+    /** Route parameters */
+    params: Record<string, string | undefined>;
+    /** Метаданные запроса (requestId, traceId, timings) */
+    meta?: RequestMeta;
+}
+/**
+ * Информация об аутентифицированном admin пользователе
+ */
+interface AdminUserContext {
+    id: number;
+    username: string;
+    email: string;
+    role: string;
+    firstName?: string | null;
+    lastName?: string | null;
+}
+/**
+ * Информация об аутентифицированном content пользователе
+ */
+interface ContentUserContext {
+    id: number;
+    username: string;
+    email: string;
+    role: string;
+}
+/**
+ * Контекст для Admin API middleware
+ */
+interface AdminMiddlewareContext extends MiddlewareBaseContext {
+    /** Admin user (если аутентифицирован) */
+    adminUser: AdminUserContext | null;
+    /** Route name (e.g., "admin:users:list", "admin:users:create") */
+    routeName: string;
+}
+/**
+ * Контекст для Content API middleware
+ */
+interface ContentMiddlewareContext extends MiddlewareBaseContext {
+    /** Content user (если аутентифицирован) */
+    user: ContentUserContext | null;
+    /** Admin user (если запрос от админа) */
+    adminUser: AdminUserContext | null;
+    /** Content type name */
+    contentType: string;
+    /** Operation type */
+    operation: ContentOperation;
+    /** Entry ID (для операций с конкретной записью) */
+    entryId?: string | number;
+}
+/**
+ * Контекст для System event middleware
+ */
+interface SystemEventContext {
+    /** Event name */
+    event: SystemEvent;
+    /** Event timestamp */
+    timestamp: Date;
+    /** Event payload (varies by event type) */
+    payload: unknown;
+}
+/**
+ * Операции над контентом
+ */
+type ContentOperation = 'create' | 'read' | 'update' | 'delete' | 'list' | 'publish' | 'unpublish' | 'bulk-update' | 'bulk-delete';
+/**
+ * Системные события
+ */
+type SystemEvent = 'app:start' | 'app:stop' | 'schema:create' | 'schema:update' | 'schema:delete' | 'schema:sync' | 'content:beforeCreate' | 'content:afterCreate' | 'content:beforeUpdate' | 'content:afterUpdate' | 'content:beforeDelete' | 'content:afterDelete' | 'content:beforeFind' | 'content:afterFind' | 'content:beforeFindMany' | 'content:afterFindMany' | 'content:beforeCount' | 'content:afterCount' | 'content:beforeQuery' | 'content:afterQuery' | 'content:beforeValidate' | 'content:afterValidate' | 'content:beforeSave' | 'content:afterSave' | 'content:beforePublish' | 'content:afterPublish' | 'content:beforeUnpublish' | 'content:afterUnpublish' | 'media:upload' | 'media:delete' | 'auth:beforeLogin' | 'auth:afterLogin' | 'auth:loginFailed' | 'auth:login' | 'auth:logout' | 'auth:register' | 'auth:tokenRefresh' | 'auth:passwordReset' | 'admin:beforeLogin' | 'admin:afterLogin' | 'admin:loginFailed' | 'admin:login' | 'admin:logout' | 'admin:tokenRefresh' | 'policy:beforeCheck' | 'policy:afterCheck';
+/**
+ * Результат выполнения middleware
+ */
+interface MiddlewareResult<T = unknown> {
+    /** Продолжить выполнение цепочки */
+    continue: boolean;
+    /** Модифицированные данные (для before* хуков) */
+    data?: T;
+    /** Ответ для клиента (если continue: false) */
+    response?: {
+        statusCode: number;
+        body: unknown;
+        headers?: Record<string, string>;
+    };
+}
+/**
+ * Admin API middleware handler
+ */
+type AdminMiddlewareHandler<TInput = unknown, TOutput = unknown> = (ctx: AdminMiddlewareContext, input: TInput, next: () => Promise<TOutput>) => Promise<TOutput | MiddlewareResult<TOutput>>;
+/**
+ * Content API middleware handler
+ */
+type ContentMiddlewareHandler<TInput = unknown, TOutput = unknown> = (ctx: ContentMiddlewareContext, input: TInput, next: () => Promise<TOutput>) => Promise<TOutput | MiddlewareResult<TOutput>>;
+/**
+ * System event handler
+ */
+type SystemEventHandler<TPayload = unknown> = (ctx: SystemEventContext & {
+    payload: TPayload;
+}) => Promise<void | {
+    payload: TPayload;
+}>;
+/**
+ * Определение middleware
+ */
+interface MiddlewareDefinition<THandler = unknown> {
+    /** Уникальное имя middleware */
+    name: string;
+    /** Внутренний тип middleware (для loader) */
+    _type?: 'admin' | 'content' | 'system';
+    /** Описание */
+    description?: string;
+    /** Порядок выполнения (меньше = раньше, default: 100) */
+    order?: number;
+    /** Паттерн маршрута или массив паттернов (glob-like) */
+    routes?: string | string[];
+    /** HTTP методы (если не указано - все) */
+    methods?: Array<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'>;
+    /** Content types (для content middleware) */
+    contentTypes?: string | string[];
+    /** Operations (для content middleware) */
+    operations?: ContentOperation | ContentOperation[];
+    /** Events (для system middleware) */
+    events?: SystemEvent | SystemEvent[];
+    /** Handler function */
+    handler: THandler;
+    /** Включен ли middleware */
+    enabled?: boolean;
+}
+/**
+ * Admin middleware definition
+ */
+type AdminMiddleware<TInput = unknown, TOutput = unknown> = MiddlewareDefinition<AdminMiddlewareHandler<TInput, TOutput>>;
+/**
+ * Content middleware definition
+ */
+type ContentMiddleware<TInput = unknown, TOutput = unknown> = MiddlewareDefinition<ContentMiddlewareHandler<TInput, TOutput>>;
+/**
+ * System event middleware definition
+ */
+type SystemMiddleware<TPayload = unknown> = MiddlewareDefinition<SystemEventHandler<TPayload>>;
+/**
+ * Конфигурация middleware для проекта
+ */
+interface MiddlewareConfig {
+    /** Admin API middleware */
+    admin?: AdminMiddleware[];
+    /** Content API middleware */
+    content?: ContentMiddleware[];
+    /** System event handlers */
+    system?: SystemMiddleware[];
+}
+/**
+ * Фабрика для создания admin middleware
+ */
+declare function defineAdminMiddleware<TInput = unknown, TOutput = unknown>(definition: AdminMiddleware<TInput, TOutput>): AdminMiddleware<TInput, TOutput>;
+/**
+ * Фабрика для создания content middleware
+ */
+declare function defineContentMiddleware<TInput = unknown, TOutput = unknown>(definition: ContentMiddleware<TInput, TOutput>): ContentMiddleware<TInput, TOutput>;
+/**
+ * Фабрика для создания system middleware
+ */
+declare function defineSystemMiddleware<TPayload = unknown>(definition: SystemMiddleware<TPayload>): SystemMiddleware<TPayload>;
+/**
+ * Admin API routes с их типами input/output
+ */
+interface AdminRouteMap {
+    'admin:users:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: AdminUserContext[];
+        };
+    };
+    'admin:users:get': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+            data: AdminUserContext;
+        };
+    };
+    'admin:users:create': {
+        input: {
+            username: string;
+            email: string;
+            password: string;
+            role?: string;
+        };
+        output: {
+            success: boolean;
+            data: AdminUserContext;
+        };
+    };
+    'admin:users:update': {
+        input: {
+            id: number;
+            username?: string;
+            email?: string;
+            role?: string;
+        };
+        output: {
+            success: boolean;
+            data: AdminUserContext;
+        };
+    };
+    'admin:users:delete': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:auth:login': {
+        input: {
+            email: string;
+            password: string;
+        };
+        output: {
+            success: boolean;
+            token: string;
+            user: AdminUserContext;
+        };
+    };
+    'admin:auth:me': {
+        input: void;
+        output: {
+            success: boolean;
+            data: AdminUserContext;
+        };
+    };
+    'admin:auth:logout': {
+        input: void;
+        output: {
+            success: boolean;
+            message: string;
+        };
+    };
+    'admin:auth:refresh': {
+        input: void;
+        output: {
+            success: boolean;
+            data: {
+                token: string;
+                user: AdminUserContext;
+            };
+        };
+    };
+    'admin:settings:get': {
+        input: void;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:settings:update': {
+        input: Record<string, unknown>;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:settings:locales:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:settings:locales:create': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:settings:locales:update': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:settings:locales:delete': {
+        input: {
+            code: string;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:settings:locales:available': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:config:get': {
+        input: void;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:config:update': {
+        input: Record<string, unknown>;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:config:reload': {
+        input: void;
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:config:import': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:config:export': {
+        input: void;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:config:schema': {
+        input: void;
+        output: {
+            success: boolean;
+            data: Record<string, unknown>;
+        };
+    };
+    'admin:schemas:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:schemas:get': {
+        input: {
+            name: string;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:schemas:create': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:schemas:update': {
+        input: {
+            name: string;
+            schema: unknown;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:schemas:delete': {
+        input: {
+            name: string;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:roles:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:roles:get': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:roles:create': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:roles:update': {
+        input: {
+            id: number;
+            data: unknown;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:roles:delete': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:webhooks:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:webhooks:get': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:webhooks:create': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:webhooks:update': {
+        input: {
+            id: number;
+            data: unknown;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:webhooks:delete': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:media:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:media:upload': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:media:delete': {
+        input: {
+            id: number;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    'admin:components:list': {
+        input: void;
+        output: {
+            success: boolean;
+            data: unknown[];
+        };
+    };
+    'admin:components:create': {
+        input: unknown;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:components:get': {
+        input: {
+            uid: string;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:components:update': {
+        input: {
+            uid: string;
+            data: unknown;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'admin:components:delete': {
+        input: {
+            uid: string;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+}
+/**
+ * Content API operations с их типами
+ */
+interface ContentOperationMap {
+    create: {
+        input: Record<string, unknown>;
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    read: {
+        input: {
+            id: string | number;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    update: {
+        input: {
+            id: string | number;
+            data: Record<string, unknown>;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    delete: {
+        input: {
+            id: string | number;
+        };
+        output: {
+            success: boolean;
+        };
+    };
+    list: {
+        input: {
+            page?: number;
+            pageSize?: number;
+            sort?: string[];
+            filters?: Record<string, unknown>;
+        };
+        output: {
+            success: boolean;
+            data: unknown[];
+            meta: {
+                page: number;
+                pageSize: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+    publish: {
+        input: {
+            id: string | number;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    unpublish: {
+        input: {
+            id: string | number;
+        };
+        output: {
+            success: boolean;
+            data: unknown;
+        };
+    };
+    'bulk-update': {
+        input: {
+            ids: (string | number)[];
+            data: Record<string, unknown>;
+        };
+        output: {
+            success: boolean;
+            updated: number;
+        };
+    };
+    'bulk-delete': {
+        input: {
+            ids: (string | number)[];
+        };
+        output: {
+            success: boolean;
+            deleted: number;
+        };
+    };
+}
+/**
+ * System event payloads
+ */
+interface SystemEventPayloadMap {
+    'app:start': {
+        timestamp: Date;
+    };
+    'app:stop': {
+        timestamp: Date;
+    };
+    'schema:create': {
+        schemaName: string;
+        schema: unknown;
+    };
+    'schema:update': {
+        schemaName: string;
+        schema: unknown;
+        previousSchema: unknown;
+    };
+    'schema:delete': {
+        schemaName: string;
+    };
+    'schema:sync': {
+        schemas: string[];
+    };
+    'content:beforeCreate': {
+        contentType: string;
+        data: Record<string, unknown>;
+    };
+    'content:afterCreate': {
+        contentType: string;
+        data: Record<string, unknown>;
+        entry: unknown;
+    };
+    'content:beforeUpdate': {
+        contentType: string;
+        id: string | number;
+        data: Record<string, unknown>;
+        previousEntry: unknown;
+    };
+    'content:afterUpdate': {
+        contentType: string;
+        id: string | number;
+        data: Record<string, unknown>;
+        entry: unknown;
+    };
+    'content:beforeDelete': {
+        contentType: string;
+        id: string | number;
+        entry: unknown;
+    };
+    'content:afterDelete': {
+        contentType: string;
+        id: string | number;
+    };
+    'content:beforeFind': {
+        contentType: string;
+        id: string | number;
+        options: {
+            populate?: string | string[];
+            locale?: string;
+        };
+    };
+    'content:afterFind': {
+        contentType: string;
+        id: string | number;
+        entry: unknown;
+    };
+    'content:beforeFindMany': {
+        contentType: string;
+        query: {
+            limit?: number;
+            offset?: number;
+            sort?: string;
+            sortOrder?: 'asc' | 'desc';
+            filters?: Record<string, unknown>;
+            published?: boolean;
+            populate?: string | string[];
+            search?: string;
+            searchFields?: string[];
+            locale?: string;
+        };
+    };
+    'content:afterFindMany': {
+        contentType: string;
+        query: Record<string, unknown>;
+        result: {
+            data: unknown[];
+            total: number;
+        };
+    };
+    'content:beforeCount': {
+        contentType: string;
+        query: {
+            filters?: Record<string, unknown>;
+            groupBy?: string[];
+        };
+    };
+    'content:afterCount': {
+        contentType: string;
+        query: Record<string, unknown>;
+        result: unknown;
+    };
+    'content:beforeQuery': {
+        contentType: string;
+        /** Operation type: read (findOne), list (findMany), count, aggregate */
+        operation: 'read' | 'list' | 'count' | 'aggregate';
+        /** Query parameters (filters, sort, pagination, search, populate) */
+        query: {
+            id?: string | number;
+            limit?: number;
+            offset?: number;
+            sort?: string;
+            sortOrder?: 'asc' | 'desc';
+            filters?: Record<string, unknown>;
+            published?: boolean;
+            populate?: string | string[];
+            search?: string;
+            searchFields?: string[];
+            locale?: string;
+            groupBy?: string[];
+            aggregate?: Record<string, string>;
+            having?: Record<string, unknown>;
+        };
+    };
+    'content:afterQuery': {
+        contentType: string;
+        /** Operation type */
+        operation: 'read' | 'list' | 'count' | 'aggregate';
+        /** Original query parameters */
+        query: Record<string, unknown>;
+        /** SQL metadata (for debugging/logging) */
+        meta?: {
+            sql?: string;
+            params?: unknown[];
+            duration?: number;
+        };
+        /** Query result */
+        result: unknown;
+    };
+    'content:beforeValidate': {
+        contentType: string;
+        operation: 'create' | 'update';
+        data: Record<string, unknown>;
+        id?: string | number;
+    };
+    'content:afterValidate': {
+        contentType: string;
+        operation: 'create' | 'update';
+        data: Record<string, unknown>;
+        id?: string | number;
+        isValid: boolean;
+        errors?: Array<{
+            field: string;
+            message: string;
+        }>;
+    };
+    'content:beforeSave': {
+        contentType: string;
+        operation: 'create' | 'update';
+        data: Record<string, unknown>;
+        id?: string | number;
+        previousEntry?: unknown;
+    };
+    'content:afterSave': {
+        contentType: string;
+        operation: 'create' | 'update';
+        data: Record<string, unknown>;
+        entry: unknown;
+        id: string | number;
+    };
+    'content:beforePublish': {
+        contentType: string;
+        id: string | number;
+        entry: unknown;
+    };
+    'content:afterPublish': {
+        contentType: string;
+        id: string | number;
+        entry: unknown;
+    };
+    'content:beforeUnpublish': {
+        contentType: string;
+        id: string | number;
+        entry: unknown;
+    };
+    'content:afterUnpublish': {
+        contentType: string;
+        id: string | number;
+        entry: unknown;
+    };
+    'media:upload': {
+        file: unknown;
+        metadata: unknown;
+    };
+    'media:delete': {
+        id: number;
+        file: unknown;
+    };
+    'auth:beforeLogin': {
+        identifier: string;
+        ip?: string;
+        userAgent?: string;
+        provider?: string;
+    };
+    'auth:afterLogin': {
+        userId: number;
+        email: string;
+        username: string;
+        role: string;
+        ip?: string;
+        userAgent?: string;
+        provider?: string;
+    };
+    'auth:loginFailed': {
+        identifier: string;
+        reason: 'invalid_credentials' | 'user_not_found' | 'user_blocked' | 'unknown';
+        ip?: string;
+        userAgent?: string;
+        provider?: string;
+    };
+    'auth:login': {
+        userId: number;
+        email: string;
+    };
+    'auth:logout': {
+        userId: number;
+        ip?: string;
+        userAgent?: string;
+    };
+    'auth:register': {
+        userId: number;
+        email: string;
+        username: string;
+        ip?: string;
+        userAgent?: string;
+    };
+    'auth:tokenRefresh': {
+        userId: number;
+        ip?: string;
+        userAgent?: string;
+    };
+    'auth:passwordReset': {
+        userId: number;
+        email: string;
+        stage: 'requested' | 'completed';
+        ip?: string;
+        userAgent?: string;
+    };
+    'admin:beforeLogin': {
+        identifier: string;
+        ip?: string;
+        userAgent?: string;
+    };
+    'admin:afterLogin': {
+        adminId: number;
+        email: string;
+        username: string;
+        role: string;
+        ip?: string;
+        userAgent?: string;
+    };
+    'admin:loginFailed': {
+        identifier: string;
+        reason: 'invalid_credentials' | 'user_not_found' | 'unknown';
+        ip?: string;
+        userAgent?: string;
+    };
+    'admin:login': {
+        adminId: number;
+        email: string;
+    };
+    'admin:logout': {
+        adminId: number;
+        ip?: string;
+        userAgent?: string;
+    };
+    'admin:tokenRefresh': {
+        adminId: number;
+        ip?: string;
+        userAgent?: string;
+    };
+    'policy:beforeCheck': {
+        /** Content type being accessed */
+        subject: string;
+        /** Action being performed */
+        action: 'create' | 'read' | 'update' | 'delete' | 'publish';
+        /** Content user (if authenticated) */
+        user: {
+            id: number;
+            username: string;
+            email: string;
+            role: string;
+        } | null;
+        /** Admin user (if request from admin) */
+        adminUser: {
+            id: number;
+            username: string;
+            email: string;
+            role: string;
+        } | null;
+        /** User's role name */
+        role: string;
+        /** Effective permissions for this role (if available) */
+        effectivePermissions?: Record<string, unknown>;
+        /** Initial decision (can be modified by middleware) */
+        decision: 'allow' | 'deny';
+    };
+    'policy:afterCheck': {
+        /** Content type being accessed */
+        subject: string;
+        /** Action being performed */
+        action: 'create' | 'read' | 'update' | 'delete' | 'publish';
+        /** Content user (if authenticated) */
+        user: {
+            id: number;
+            username: string;
+            email: string;
+            role: string;
+        } | null;
+        /** Admin user (if request from admin) */
+        adminUser: {
+            id: number;
+            username: string;
+            email: string;
+            role: string;
+        } | null;
+        /** User's role name */
+        role: string;
+        /** Final decision */
+        decision: 'allow' | 'deny';
+        /** Reason for the decision */
+        reason?: string;
+        /** Was decision overridden by middleware? */
+        overridden?: boolean;
+    };
+}
+/**
+ * Типизированный system middleware handler
+ */
+type TypedSystemEventHandler<E extends SystemEvent> = SystemEventHandler<SystemEventPayloadMap[E]>;
+/**
+ * Типизированный admin middleware для конкретного route
+ */
+type TypedAdminMiddleware<R extends keyof AdminRouteMap> = AdminMiddleware<AdminRouteMap[R]['input'], AdminRouteMap[R]['output']>;
+/**
+ * Типизированный content middleware для конкретной операции
+ */
+type TypedContentMiddleware<O extends ContentOperation> = ContentMiddleware<ContentOperationMap[O]['input'], ContentOperationMap[O]['output']>;
+
+export { type ACmsField, type ACmsSchema, type AdminMiddleware, type AdminMiddlewareContext, type AdminMiddlewareHandler, type AdminRouteMap, type AdminUserContext, type ComponentData, type ComponentDataInput, type ComponentFieldData, type ComponentFieldInput, type ComponentSchema, type ContentEntry, type ContentMiddleware, type ContentMiddlewareContext, type ContentMiddlewareHandler, type ContentOperation, type ContentOperationMap, type ContentUserContext, type DynamicZoneData, type DynamicZoneInput, type DynamicZoneItem, type DynamicZoneItemInput, type FieldType, type MediaType, type MiddlewareBaseContext, type MiddlewareChainResult, type MiddlewareConfig, type MiddlewareDefinition, type MiddlewareError, type MiddlewareObserver, type MiddlewareResult, type MiddlewareTiming, type Migration, type MigrationDatabaseConnection, type MigrationRecord, type MigrationResult, type MigrationStatus, type MySQLMigrationConnection, type Plugin, type PluginHooks, type PostgresMigrationConnection, type QueryOptions, type RequestMeta, type RollbackResult, type SQLiteMigrationConnection, type SchemaKind, SchemaValidationError, type SystemEvent, type SystemEventContext, type SystemEventHandler, type SystemEventPayloadMap, type SystemMiddleware, type Theme, type ThemeConfig, type TypedAdminMiddleware, type TypedContentMiddleware, type TypedSystemEventHandler, type User, type ValidationError, type ValidationErrorCode, type ValidationResult, defineAdminMiddleware, defineContentMiddleware, defineSystemMiddleware, exampleBlockComponent, exampleComponentSchema, exampleSchema };