@acorex/platform 21.0.0-next.5 → 21.0.0-next.51

package/{native/index.d.ts → types/acorex-platform-native.d.ts}

@@ -6,13 +6,6 @@ declare class AXPNativeModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<AXPNativeModule>;
 }
 
-declare global {
-    interface Window {
-        FlutterChannel?: {
-            postMessage: (message: string) => void;
-        };
-    }
-}
 declare class AXPNativeService {
     private isDark;
     constructor();

package/types/acorex-platform-runtime.d.ts

@@ -0,0 +1,571 @@
+import { AXPDefinitionCategory, AXPExecuteCommandResult, AXPViewDefinition, AXPMetaData } from '@acorex/platform/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Type, Provider } from '@angular/core';
+import { AXComponent } from '@acorex/cdk/common';
+
+/**
+ * Shared build-time catalog metadata for command, query, and widget definition sidecars
+ * (`defineCommand`, `defineQuery`, `defineWidget`).
+ * Lives under `shared/` so consumers import one module without a "command" prefix on generic shapes.
+ */
+
+/** Catalog metadata validation: rule key + optional rule options only. */
+interface AXPCatalogValidationRuleValue {
+    rule: string;
+    options?: Record<string, unknown>;
+}
+/**
+ * Widget/interface reference for a schema property (name + optional widget options).
+ */
+interface AXPCatalogInterfaceDefinitionValue {
+    name: string;
+    options?: Record<string, unknown>;
+}
+/**
+ * Agent-facing hints when a single catalog row can be satisfied in several ways
+ * (inline list, registry-backed dataSource key, query + assign, tabular columns, context merge, etc.).
+ * Documentation only; tooling may surface this next to `description` and `interface`.
+ */
+interface AXPCatalogPropertyBindingHints {
+    /** Named strategies the agent or author may use to supply this parameter. */
+    strategies?: readonly string[];
+    /** Short concrete examples (strings or JSON fragments as documentation, not executed). */
+    examples?: readonly string[];
+    /** Extra notes: merge rules, mode flags, registry keys, or when to prefer one strategy over another. */
+    notes?: string;
+}
+/**
+ * One input/output property description (same structural role as entity option definitions).
+ */
+interface AXPCatalogSchemaPropertyDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    defaultValue?: unknown;
+    disabled?: boolean;
+    interface: AXPCatalogInterfaceDefinitionValue;
+    validations?: AXPCatalogValidationRuleValue[];
+    /**
+     * Optional multi-strategy binding documentation for AI and codegen (commands, queries, widget sidecars).
+     * Prefer this over inventing a non-form `interface.name` that is not part of the AI-facing widget catalog.
+     */
+    bindingHints?: AXPCatalogPropertyBindingHints;
+}
+/** Structured usage hints for planners and assistants (prefer over duplicating rules only in `description`). */
+interface AXPCatalogAiUsageMetadata {
+    whenToUse?: string[];
+    avoidWhen?: string[];
+    /** Registry keys or tool names that commonly follow this catalog entry. */
+    followUpTools?: string[];
+}
+/** Declarative contracts: what the entry provides, who depends on it, and guarantees. */
+interface AXPCatalogAiContractsMetadata {
+    provides?: string[];
+    requiredBy?: string[];
+    guarantees?: string[];
+}
+type AXPCatalogAiSafetyKind = 'read-only' | 'mutating';
+interface AXPCatalogAiSafetyMetadata {
+    kind?: AXPCatalogAiSafetyKind;
+    sideEffects?: boolean;
+    requiresConfirmation?: boolean;
+}
+type AXPCatalogAiPerformanceCost = 'low' | 'medium' | 'high';
+interface AXPCatalogAiPerformanceMetadata {
+    cost?: AXPCatalogAiPerformanceCost;
+    cacheable?: boolean;
+}
+interface AXPCatalogAiNextStepMetadata {
+    when: string;
+    action: string;
+}
+/**
+ * How to interpret a successful payload for agents (documentation only; not live workflow step outcomes).
+ */
+interface AXPCatalogAiResultSemanticsMetadata {
+    noMatch?: string;
+    exactMatch?: string;
+    multipleMatches?: string;
+    failed?: string;
+    /** Full catalog listing (e.g. no entity filter). */
+    catalog?: string;
+}
+interface AXPCatalogAiMetadata {
+    shortDescription?: string;
+    /**
+     * Long-form guidance appended to LLM tool descriptions (not for short UI/registry copy).
+     * Keep root `description` concise for pickers and entity rows.
+     */
+    instruction?: string;
+    tags?: string[];
+    usage?: AXPCatalogAiUsageMetadata;
+    contracts?: AXPCatalogAiContractsMetadata;
+    safety?: AXPCatalogAiSafetyMetadata;
+    performance?: AXPCatalogAiPerformanceMetadata;
+    nextSteps?: AXPCatalogAiNextStepMetadata[];
+    resultSemantics?: AXPCatalogAiResultSemanticsMetadata;
+    /**
+     * Default input fragment merged for AI/tool invocations (catalog & tooling).
+     * Runtime merge for a given entry is applied in the AI module (not the generic command executor).
+     */
+    toolInputDefaults?: Record<string, unknown>;
+    /**
+     * Optional JSON Schema fragment for LLM tool `parameters` (OpenAI-style function calling).
+     * Merged over the auto-generated schema from catalog `inputs` (`properties` / `required` deep-merged).
+     * Use when widget-to-type inference is insufficient (e.g. `object`, `array`, `enum`, `format`).
+     */
+    toolParametersSchema?: Record<string, unknown>;
+}
+type AXPCatalogExecutionMode = 'frontend' | 'backend' | 'both';
+/**
+ * Where this catalog entry is intended to appear in product tooling (AI agents, workflow automation pickers, etc.).
+ * Omitted = not declared here; runtimes may fall back to other metadata (e.g. `ai.tags`).
+ */
+type AXPCatalogCapability = 'ai' | 'workflow';
+interface AXPCatalogMetadataDefinitionBase {
+    title: string;
+    description: string;
+    inputs?: AXPCatalogSchemaPropertyDefinition[];
+    outputs?: AXPCatalogSchemaPropertyDefinition[];
+    ai?: AXPCatalogAiMetadata;
+    capabilities?: AXPCatalogCapability[];
+    categories?: AXPDefinitionCategory | AXPDefinitionCategory[];
+}
+
+/**
+ * Build-time command metadata for AXPCommand implementations.
+ * `inputs` / `outputs` are schema rows (same family as entity optionDefinitions).
+ * Validation entries: only `rule` name and optional `options` (no title/message on rules).
+ * Do not import from Angular templates; sidecars may import `defineCommand` from `@acorex/platform/runtime`.
+ *
+ * Query metadata (fetch-only, no outcomes) is defined in `../queries/query-definition.types.ts` with `defineQuery`.
+ * Widget metadata sidecars use `../widgets/widget-definition.types.ts` with `defineWidget`.
+ */
+
+type AXPCommandOutcomeDefinition = {
+    mode: 'static';
+    values: string[];
+} | {
+    mode: 'dynamic';
+    summary: string;
+    derivesFrom: string;
+    examples?: string[];
+};
+interface AXPCommandMetadataDefinition extends AXPCatalogMetadataDefinitionBase {
+    /** Runtime registration key (provideCommand / provideCommandSetups). */
+    key: string;
+    executionMode: AXPCatalogExecutionMode;
+    outcomes: AXPCommandOutcomeDefinition;
+}
+
+/**
+ * Typed identity helper for command metadata sidecars.
+ */
+declare function defineCommand<T extends AXPCommandMetadataDefinition>(definition: T): T;
+
+declare const AXP_CATALOG_DEFINITION_CATEGORY_PLATFORM: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_ENTITY: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_STORAGE: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_WIDGETS: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_WORKFLOW: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_UTILITY: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_SETTINGS: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_AI_TOOLS: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_SECURITY: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_DATA_MANAGEMENT: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_ASSESSMENT: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_REPORT: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_ORGANIZATION: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_TENANT: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_HUMAN_CAPITAL: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_PRODUCT: AXPDefinitionCategory;
+declare const AXP_CATALOG_DEFINITION_CATEGORY_FILE_WIDGET: AXPDefinitionCategory;
+
+type AXPCommandExecutionStage = 'before' | 'after';
+interface AXPCommandExecutionEvent<TInput = unknown, TResult = unknown> {
+    stage: AXPCommandExecutionStage;
+    key: string;
+    input: TInput;
+    success?: boolean;
+    result?: AXPExecuteCommandResult<TResult> | null;
+    error?: unknown;
+}
+type CommandExecutionHandler<TInput, TResult> = (event: AXPCommandExecutionEvent<TInput, TResult>) => void;
+declare class AXPCommandEventsService {
+    private readonly broadcast;
+    private readonly distributedEvents;
+    listen<TInput = unknown, TResult = unknown>(handler: CommandExecutionHandler<TInput, TResult>): () => void;
+    emit<TInput = unknown, TResult = unknown>(event: AXPCommandExecutionEvent<TInput, TResult>): Promise<void>;
+    /**
+     * Removes functions, symbols, and cycles so {@link AXPBroadcastEventService.publish}
+     * can use `BroadcastChannel.postMessage` without DataCloneError (e.g. command input with `dialogRef`).
+     */
+    private serializeForBroadcast;
+    private stripNonSerializable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommandEventsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommandEventsService>;
+}
+
+declare class AXPCommandExecutor {
+    private readonly injector;
+    private readonly registry;
+    private readonly extensions;
+    private readonly commandEvents;
+    execute<TInput = any, TResult = any>(key: string, input: TInput): Promise<AXPExecuteCommandResult<TResult> | null>;
+    private getPluginMiddlewares;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommandExecutor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommandExecutor>;
+}
+
+/**
+ * Represents a middleware function in the command execution pipeline.
+ */
+type AXPCommandMiddleware<TInput = any, TResult = any> = (input: TInput, next: (input: TInput) => Promise<AXPExecuteCommandResult<TResult>>) => Promise<AXPExecuteCommandResult<TResult>>;
+/**
+ * Creates a composed handler by chaining the provided command middlewares.
+ */
+declare function composeCommandMiddlewares<TInput, TResult>(middlewares: AXPCommandMiddleware<TInput, TResult>[]): (handler: (input: TInput) => Promise<AXPExecuteCommandResult<TResult>>) => (input: TInput) => Promise<AXPExecuteCommandResult<TResult>>;
+
+interface AXPCommandExtension {
+    target: string | RegExp;
+    middleware: AXPCommandMiddleware;
+}
+declare const AXP_COMMAND_EXTENSION: InjectionToken<AXPCommandExtension[]>;
+
+type AXPExecuteCommandResultPromise<TResult = any> = Promise<AXPExecuteCommandResult<TResult>>;
+interface AXPCommand<TInput = any, TResult = any> {
+    execute(input: TInput): AXPExecuteCommandResultPromise<TResult>;
+}
+
+declare class AXPCommandRegistry {
+    private registry;
+    private middlewares;
+    register(key: string, loader: () => Promise<AXPCommand>): void;
+    unregister(key: string): boolean;
+    use(middleware: AXPCommandMiddleware): void;
+    exists(key: string): boolean;
+    getLoader(key: string): (() => Promise<AXPCommand>) | undefined;
+    getMiddlewares(): readonly AXPCommandMiddleware[];
+    getRegisteredKeys(): string[];
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommandRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommandRegistry>;
+}
+
+declare class AXPCommandService {
+    private readonly registry;
+    private readonly executor;
+    register(key: string, loader: () => Promise<AXPCommand>): void;
+    unregister(key: string): boolean;
+    use(middleware: AXPCommandMiddleware): void;
+    exists(key: string): boolean;
+    getRegisteredKeys(): string[];
+    clear(): void;
+    execute<TInput = any, TResult = any>(key: string, input: TInput): Promise<AXPExecuteCommandResult<TResult> | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommandService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommandService>;
+}
+
+declare const AXP_COMMAND_MIDDLEWARE_SETUP: InjectionToken<void>;
+type AXPCommandMiddlewareEntry = (AXPCommandMiddleware | {
+    target: string | RegExp;
+    middleware: AXPCommandMiddleware;
+})[];
+declare function provideCommandMiddleware(entries: AXPCommandMiddlewareEntry): EnvironmentProviders;
+
+declare const AXP_COMMAND_SETUP: InjectionToken<void>;
+type AXPCommandLoader = {
+    key: string;
+    command: () => Type<AXPCommand> | Promise<Type<AXPCommand>>;
+};
+declare function provideCommandSetups(entries: AXPCommandLoader[]): EnvironmentProviders;
+declare function provideCommand(key: string, loader: () => Type<AXPCommand> | Promise<Type<AXPCommand>>): EnvironmentProviders;
+
+/**
+ * Build-time query metadata for AXPQuery implementations.
+ * Mirrors command metadata shape except there are no `outcomes` (queries only `fetch`).
+ * Shares {@link AXPCatalogMetadataDefinitionBase} with commands and widgets; `inputs` / `outputs` live on the base.
+ */
+
+/** One input/output property description for query definitions (same as command / widget catalog rows). */
+type AXPQuerySchemaPropertyDefinition = AXPCatalogSchemaPropertyDefinition;
+interface AXPQueryMetadataDefinition extends AXPCatalogMetadataDefinitionBase {
+    /** Runtime registration key (provideQuerySetups). */
+    key: string;
+    executionMode: AXPCatalogExecutionMode;
+}
+
+/**
+ * Typed identity helper for query metadata sidecars.
+ */
+declare function defineQuery<T extends AXPQueryMetadataDefinition>(definition: T): T;
+
+type AXPQueryMiddleware<TInput = any, TResult = any> = (input: TInput, next: (input: TInput) => Promise<TResult>) => Promise<TResult>;
+declare function composeQueryMiddlewares<TInput, TResult>(middlewares: AXPQueryMiddleware<TInput, TResult>[]): (handler: (input: TInput) => Promise<TResult>) => (input: TInput) => Promise<TResult>;
+
+declare const AXP_QUERY_MIDDLEWARE_SETUP: InjectionToken<void>;
+type AXPQueryMiddlewareEntry = (AXPQueryMiddleware | {
+    key: string;
+    middleware: AXPQueryMiddleware;
+})[];
+declare function provideQueryMiddleware(entries: AXPQueryMiddlewareEntry): EnvironmentProviders;
+
+interface AXPQuery<TInput = any, TResult = any> {
+    fetch(input: TInput): Promise<TResult>;
+}
+
+declare const AXP_QUERY_SETUP: InjectionToken<void>;
+type AXPQueryLoaderEntry = {
+    key: string;
+    loader: () => Type<AXPQuery> | Promise<Type<AXPQuery>>;
+};
+declare function provideQuerySetups(entries: AXPQueryLoaderEntry[]): EnvironmentProviders;
+
+declare class AXPQueryExecutor {
+    private readonly injector;
+    private readonly registry;
+    private readonly extensions;
+    fetch<TInput = any, TResult = any>(key: string, input: TInput): Promise<TResult | null>;
+    private getPluginMiddlewares;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPQueryExecutor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPQueryExecutor>;
+}
+
+interface AXPQueryExtension {
+    target: string | RegExp;
+    middleware: AXPQueryMiddleware;
+}
+declare const AXP_QUERY_EXTENSION: InjectionToken<AXPQueryExtension[]>;
+
+declare class AXPQueryRegistry {
+    private registry;
+    private middlewares;
+    register(key: string, loader: () => Promise<AXPQuery>): void;
+    unregister(key: string): boolean;
+    use(middleware: AXPQueryMiddleware): void;
+    exists(key: string): boolean;
+    getLoader(key: string): (() => Promise<AXPQuery>) | undefined;
+    getMiddlewares(): readonly AXPQueryMiddleware[];
+    getRegisteredKeys(): string[];
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPQueryRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPQueryRegistry>;
+}
+
+declare class AXPQueryService {
+    private readonly registry;
+    private readonly executor;
+    register(key: string, loader: () => Promise<AXPQuery>): void;
+    unregister(key: string): boolean;
+    use(middleware: AXPQueryMiddleware): void;
+    exists(key: string): boolean;
+    getRegisteredKeys(): string[];
+    clear(): void;
+    fetch<TInput = any, TResult = any>(key: string, input: TInput): Promise<TResult | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPQueryService>;
+}
+
+/**
+ * Build-time widget metadata sidecars (parallel to {@link AXPWidgetConfig} in layout/widget-core).
+ * Extends {@link AXPCatalogMetadataDefinitionBase}; `inputs` / `outputs` use the same schema rows as commands/queries.
+ * Sidecars may import `defineWidget` from `@acorex/platform/runtime`.
+ */
+
+/** Same surface values as {@link AXPWidgetViewType} in layout/widget-core. */
+type AXPWidgetMetadataViewType = 'container' | 'editor' | 'action' | 'view' | 'filter' | 'validation' | 'dashboard';
+/** Same values as {@link AXPWidgetGroup} / {@link AXPWidgetGroupEnum} in layout/widget-core. */
+type AXPWidgetMetadataGroup = 'form-element' | 'dashboard-widget' | 'form-template' | 'property-editor' | 'meta-data' | 'setting-widget' | 'entity-widget' | 'utility-widget' | 'base-widget';
+/**
+ * Built-in default filter widget names from {@link AXPWidgetConfig.defaultFilterWidgetName}.
+ * Other string values remain valid for custom filters.
+ */
+type AXPWidgetMetadataDefaultFilterName = 'string-filter' | 'number-filter' | 'datetime-filter' | 'boolean-filter' | 'select-filter' | 'lookup-filter' | 'time-duration-filter';
+/**
+ * Widget renderer surface aligned with {@link AXPWidgetConfig.components} keys in layout/widget-core.
+ */
+type AXPWidgetAiRenderSurfaceMode = 'view' | 'edit' | 'column' | 'designer' | 'print' | 'filter';
+/**
+ * One line of guidance for agents: which Angular component runs in this surface and how it relates to data.
+ */
+interface AXPWidgetAiRenderSurface {
+    mode: AXPWidgetAiRenderSurfaceMode;
+    summary: string;
+}
+/**
+ * AI hints for layout/form agents beyond {@link AXPCatalogAiMetadata}.
+ * Prefer `outputs` on {@link AXPCatalogMetadataDefinitionBase} for structured bound-value shape;
+ * use `renderSurfaces` for per-mode behavior (e.g. grid uses `column`, not `edit`).
+ */
+interface AXPWidgetAiMetadata extends AXPCatalogAiMetadata {
+    /** Per-surface rendering notes (view vs edit vs column vs designer). */
+    renderSurfaces?: readonly AXPWidgetAiRenderSurface[];
+    /** Other widget `name` values often used next to or instead of this one. */
+    relatedWidgetNames?: string[];
+    /**
+     * Short layout or options snippets for few-shot style documentation (not executed).
+     */
+    layoutExamples?: string[];
+}
+interface AXPWidgetMetadataDefinition extends Omit<AXPCatalogMetadataDefinitionBase, 'capabilities'> {
+    /** Runtime widget registry name (same role as `AXPWidgetConfig.name`). */
+    name: string;
+    icon?: string;
+    subCategory?: AXPDefinitionCategory;
+    groups?: readonly AXPWidgetMetadataGroup[];
+    defaultFilterWidgetName?: AXPWidgetMetadataDefaultFilterName | string;
+    type: AXPWidgetMetadataViewType;
+    /**
+     * Widget-specific AI block (subtype of base `ai`); omit to use plain {@link AXPCatalogAiMetadata} from base.
+     */
+    ai?: AXPWidgetAiMetadata;
+}
+
+/**
+ * Typed identity helper for widget metadata sidecars.
+ */
+declare function defineWidget<T extends AXPWidgetMetadataDefinition>(definition: T): T;
+
+interface AXPViewProvider<TInput = any> {
+    provide(input: TInput): Promise<AXPViewDefinition>;
+}
+
+type AXPViewMiddleware<TInput = any> = (input: TInput, next: (input: TInput) => Promise<AXPViewDefinition>) => Promise<AXPViewDefinition>;
+declare function composeViewMiddlewares<TInput>(middlewares: AXPViewMiddleware<TInput>[]): (handler: (input: TInput) => Promise<AXPViewDefinition>) => (input: TInput) => Promise<AXPViewDefinition>;
+
+declare class AXPViewRegistry {
+    private registry;
+    private middlewares;
+    register(key: string, loader: () => Promise<AXPViewProvider>): void;
+    unregister(key: string): boolean;
+    use(middleware: AXPViewMiddleware): void;
+    exists(key: string): boolean;
+    getLoader(key: string): (() => Promise<AXPViewProvider>) | undefined;
+    getMiddlewares(): readonly AXPViewMiddleware[];
+    getRegisteredKeys(): string[];
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPViewRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPViewRegistry>;
+}
+
+declare class AXPViewExecutor {
+    private readonly injector;
+    private readonly registry;
+    private readonly extensions;
+    provide<TInput = any>(key: string, input: TInput): Promise<AXPViewDefinition | null>;
+    private getPluginMiddlewares;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPViewExecutor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPViewExecutor>;
+}
+
+declare class AXPViewService {
+    private readonly registry;
+    private readonly executor;
+    register(key: string, loader: () => Promise<AXPViewProvider>): void;
+    unregister(key: string): boolean;
+    use(middleware: AXPViewMiddleware): void;
+    exists(key: string): boolean;
+    getRegisteredKeys(): string[];
+    clear(): void;
+    provide<TInput = any>(key: string, input: TInput): Promise<AXPViewDefinition | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPViewService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPViewService>;
+}
+
+interface AXPViewExtension {
+    target: string | RegExp;
+    middleware: AXPViewMiddleware;
+}
+declare const AXP_VIEW_EXTENSION: InjectionToken<AXPViewExtension[]>;
+
+declare const AXP_VIEW_SETUP: InjectionToken<void>;
+declare function provideViewSetups(providers: Provider[]): EnvironmentProviders;
+declare function provideViewSetup(key: string, loader: () => Promise<AXPViewProvider>): Provider;
+
+type AXPPolicyOptions = {
+    id: string;
+    sender: HTMLElement | AXComponent | AXPMetaData;
+    policies?: string[];
+};
+
+interface AXPPolicy {
+    apply(context: AXPPolicyEngineContext): Promise<void>;
+}
+declare class AXPPolicyEngineContext {
+    private _id;
+    private _sender;
+    private _visible;
+    private _enabled;
+    constructor(options: AXPPolicyOptions);
+    get sender(): AXPPolicyOptions['sender'];
+    get id(): string;
+    get visible(): boolean;
+    get enabled(): boolean;
+    setVisible(visible: boolean): this;
+    setEnabled(enabled: boolean): this;
+}
+
+type AXPPolicyEngineMiddleware = (context: AXPPolicyEngineContext, next: (context: AXPPolicyEngineContext) => Promise<void>) => Promise<void>;
+declare function composePolicyEngineMiddlewares(middlewares: AXPPolicyEngineMiddleware[]): (handler: (context: AXPPolicyEngineContext) => Promise<void>) => (context: AXPPolicyEngineContext) => Promise<void>;
+
+declare class AXPPolicyEngineRegistry {
+    private registry;
+    private middlewares;
+    private extensions;
+    private injector;
+    use(mw: AXPPolicyEngineMiddleware): void;
+    exists(key: string): boolean;
+    getPolicies(): string[];
+    register(key: string, loader: () => Promise<AXPPolicy>): void;
+    private getPluginMiddlewares;
+    execute(policy: string, instance: AXPPolicyOptions): Promise<AXPPolicyEngineContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPolicyEngineRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPolicyEngineRegistry>;
+}
+
+declare class AXPPolicyEngineService {
+    private registry;
+    apply(options: AXPPolicyOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPolicyEngineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPolicyEngineService>;
+}
+
+declare class AXPPolicyEngineDirective {
+    #private;
+    policy: i0.InputSignal<string | null | undefined>;
+    private service;
+    private elementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPolicyEngineDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPPolicyEngineDirective, "[axp-apply-policy]", never, { "policy": { "alias": "axp-apply-policy"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AXPPolicyExtension {
+    key: string;
+    middleware: AXPPolicyEngineMiddleware;
+}
+declare const AXP_POLICY_EXTENSION: InjectionToken<AXPPolicyExtension[]>;
+
+declare const AXP_POLICY_ENGINE_MIDDLEWARE_SETUP: InjectionToken<void>;
+type AXPPolicyLoader = {
+    key: string;
+    policy: () => Type<AXPPolicy> | Promise<Type<AXPPolicy>>;
+};
+declare function providePolicySetups(entries: AXPPolicyLoader[]): EnvironmentProviders;
+
+declare class AXPRuntimeModule {
+    private _commandSetup;
+    private _commandMiddlewareSetup;
+    private _querySetup;
+    private _queryMiddlewareSetup;
+    private _viewSetup;
+    private _viewMiddlewareSetup;
+    private _policyEngineSetup;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPRuntimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPRuntimeModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPRuntimeModule>;
+}
+
+export { AXPCommandEventsService, AXPCommandExecutor, AXPCommandRegistry, AXPCommandService, AXPPolicyEngineContext, AXPPolicyEngineDirective, AXPPolicyEngineRegistry, AXPPolicyEngineService, AXPQueryExecutor, AXPQueryRegistry, AXPQueryService, AXPRuntimeModule, AXPViewExecutor, AXPViewRegistry, AXPViewService, AXP_CATALOG_DEFINITION_CATEGORY_AI_TOOLS as AXP_COMMAND_DEFINITION_CATEGORY_AI_TOOLS, AXP_CATALOG_DEFINITION_CATEGORY_ASSESSMENT as AXP_COMMAND_DEFINITION_CATEGORY_ASSESSMENT, AXP_CATALOG_DEFINITION_CATEGORY_DATA_MANAGEMENT as AXP_COMMAND_DEFINITION_CATEGORY_DATA_MANAGEMENT, AXP_CATALOG_DEFINITION_CATEGORY_ENTITY as AXP_COMMAND_DEFINITION_CATEGORY_ENTITY, AXP_CATALOG_DEFINITION_CATEGORY_FILE_WIDGET as AXP_COMMAND_DEFINITION_CATEGORY_FILE_WIDGET, AXP_CATALOG_DEFINITION_CATEGORY_HUMAN_CAPITAL as AXP_COMMAND_DEFINITION_CATEGORY_HUMAN_CAPITAL, AXP_CATALOG_DEFINITION_CATEGORY_ORGANIZATION as AXP_COMMAND_DEFINITION_CATEGORY_ORGANIZATION, AXP_CATALOG_DEFINITION_CATEGORY_PLATFORM as AXP_COMMAND_DEFINITION_CATEGORY_PLATFORM, AXP_CATALOG_DEFINITION_CATEGORY_PRODUCT as AXP_COMMAND_DEFINITION_CATEGORY_PRODUCT, AXP_CATALOG_DEFINITION_CATEGORY_REPORT as AXP_COMMAND_DEFINITION_CATEGORY_REPORT, AXP_CATALOG_DEFINITION_CATEGORY_SECURITY as AXP_COMMAND_DEFINITION_CATEGORY_SECURITY, AXP_CATALOG_DEFINITION_CATEGORY_SETTINGS as AXP_COMMAND_DEFINITION_CATEGORY_SETTINGS, AXP_CATALOG_DEFINITION_CATEGORY_STORAGE as AXP_COMMAND_DEFINITION_CATEGORY_STORAGE, AXP_CATALOG_DEFINITION_CATEGORY_TENANT as AXP_COMMAND_DEFINITION_CATEGORY_TENANT, AXP_CATALOG_DEFINITION_CATEGORY_UTILITY as AXP_COMMAND_DEFINITION_CATEGORY_UTILITY, AXP_CATALOG_DEFINITION_CATEGORY_WORKFLOW as AXP_COMMAND_DEFINITION_CATEGORY_WORKFLOW, AXP_COMMAND_EXTENSION, AXP_COMMAND_MIDDLEWARE_SETUP, AXP_COMMAND_SETUP, AXP_POLICY_ENGINE_MIDDLEWARE_SETUP, AXP_POLICY_EXTENSION, AXP_CATALOG_DEFINITION_CATEGORY_ENTITY as AXP_QUERY_DEFINITION_CATEGORY_ENTITY, AXP_CATALOG_DEFINITION_CATEGORY_PLATFORM as AXP_QUERY_DEFINITION_CATEGORY_PLATFORM, AXP_CATALOG_DEFINITION_CATEGORY_STORAGE as AXP_QUERY_DEFINITION_CATEGORY_STORAGE, AXP_CATALOG_DEFINITION_CATEGORY_WIDGETS as AXP_QUERY_DEFINITION_CATEGORY_WIDGETS, AXP_QUERY_EXTENSION, AXP_QUERY_MIDDLEWARE_SETUP, AXP_QUERY_SETUP, AXP_VIEW_EXTENSION, AXP_VIEW_SETUP, composeCommandMiddlewares, composePolicyEngineMiddlewares, composeQueryMiddlewares, composeViewMiddlewares, defineCommand, defineQuery, defineWidget, provideCommand, provideCommandMiddleware, provideCommandSetups, providePolicySetups, provideQueryMiddleware, provideQuerySetups, provideViewSetup, provideViewSetups };
+export type { AXPCatalogAiContractsMetadata, AXPCatalogAiMetadata, AXPCatalogAiNextStepMetadata, AXPCatalogAiPerformanceCost, AXPCatalogAiPerformanceMetadata, AXPCatalogAiResultSemanticsMetadata, AXPCatalogAiSafetyKind, AXPCatalogAiSafetyMetadata, AXPCatalogAiUsageMetadata, AXPCatalogCapability, AXPCatalogExecutionMode, AXPCatalogInterfaceDefinitionValue, AXPCatalogMetadataDefinitionBase, AXPCatalogPropertyBindingHints, AXPCatalogSchemaPropertyDefinition, AXPCatalogValidationRuleValue, AXPCommand, AXPCommandExecutionEvent, AXPCommandExecutionStage, AXPCommandExtension, AXPCommandMetadataDefinition, AXPCommandMiddleware, AXPCommandOutcomeDefinition, AXPExecuteCommandResultPromise, AXPPolicy, AXPPolicyEngineMiddleware, AXPPolicyExtension, AXPQuery, AXPQueryExtension, AXPQueryMetadataDefinition, AXPQueryMiddleware, AXPQuerySchemaPropertyDefinition, AXPViewExtension, AXPViewMiddleware, AXPViewProvider, AXPWidgetAiMetadata, AXPWidgetAiRenderSurface, AXPWidgetAiRenderSurfaceMode, AXPWidgetMetadataDefaultFilterName, AXPWidgetMetadataDefinition, AXPWidgetMetadataGroup, AXPWidgetMetadataViewType };