@praxisui/ai 0.0.1

package/index.d.ts

@@ -0,0 +1,1216 @@
+import * as i0 from '@angular/core';
+import { OnInit, ChangeDetectorRef, OnDestroy, ElementRef } from '@angular/core';
+import * as _praxisui_core from '@praxisui/core';
+import { AiValueKind, AiCapability, GlobalConfigService, GlobalAiConfig, RulePropertySchema } from '@praxisui/core';
+import { Observable } from 'rxjs';
+import { Schema } from '@google/generative-ai';
+import { MatDialogRef } from '@angular/material/dialog';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { FunctionRegistry, ContextProvider, ValidationIssue } from '@praxisui/specification';
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+
+declare class PraxisAi {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisAi, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisAi, "lib-praxis-ai", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Models for Praxis AI (Centralized)
+ */
+
+/**
+ * Response structure expected from the AI model
+ */
+interface AiRuleResponse {
+    /** Descriptive name for the rule */
+    ruleName: string;
+    /** Type of target (scope) */
+    targetType: 'field' | 'section' | 'action' | 'row' | 'column';
+    /** IDs of the target elements */
+    targetIds: string[];
+    /** Condition in DSL format (e.g., "age >= 18") or null for always applied */
+    conditionDsl: string | null;
+    /** Effects to apply */
+    effects: {
+        /** Properties to apply when condition is true */
+        properties?: Record<string, any>;
+        /** Properties to apply when condition is false (else) */
+        propertiesWhenFalse?: Record<string, any>;
+    };
+}
+/**
+ * Minified field representation for AI context (token optimization)
+ */
+interface MinifiedField {
+    id: string;
+    label: string;
+    type: string;
+    category?: string;
+    allowedValues?: Array<{
+        value: any;
+        label: string;
+    }>;
+}
+/**
+ * Context structure sent to the AI
+ */
+interface PromptContext {
+    /** List of available fields formatted for the prompt */
+    fieldsText: string;
+    /** List of available properties for the selected target type */
+    propertiesText: string;
+    /** List of supported DSL operators */
+    operatorsText: string;
+    /** Selected target type */
+    targetType: string;
+    /** Structured list of fields for richer prompt suggestions */
+    minifiedFields?: MinifiedField[];
+}
+/**
+ * Example pair for Few-Shot Learning
+ */
+interface AiExamplePair {
+    userPrompt: string;
+    expectedResponse: AiRuleResponse;
+}
+/**
+ * Configuration for the AI Service
+ */
+interface AiIntegrationConfig {
+    /** LLM provider (gemini/openai/xai/mock) */
+    provider?: string;
+    /** Gemini API Key (optional if using proxy/env) */
+    apiKey?: string;
+    /** Model version to use */
+    model: string;
+    /** Temperature (creativity vs determinism) */
+    temperature: number;
+    /** Max output tokens */
+    maxTokens: number;
+    /** Request timeout in ms */
+    timeout: number;
+    /** Number of retry attempts */
+    retryAttempts: number;
+    /** Optional: Backend gateway URL for Enterprise mode */
+    gatewayUrl?: string;
+}
+/**
+ * Result of validating an AI response
+ */
+interface AiValidationResult {
+    valid: boolean;
+    errors: AiValidationError[];
+    warnings: AiValidationWarning[];
+    correctedResponse?: AiRuleResponse;
+}
+interface AiValidationError {
+    field: string;
+    message: string;
+    severity: 'critical' | 'error' | 'warning';
+    code: string;
+}
+interface AiValidationWarning {
+    field: string;
+    message: string;
+    suggestion?: string;
+}
+interface AiModel {
+    name: string;
+    version: string;
+    displayName: string;
+    description: string;
+    inputTokenLimit: number;
+    outputTokenLimit: number;
+    supportedGenerationMethods: string[];
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}
+type ValueKind = AiValueKind;
+type Capability = AiCapability;
+
+declare class PraxisAiService {
+    private globalConfigService;
+    private genAI;
+    private config;
+    constructor(globalConfigService: GlobalConfigService);
+    private syncConfig;
+    classifyIntent(userInput: string, columns: string[]): Observable<any>;
+    answerQuestion(userInput: string, targetConfig: any): Observable<string>;
+    executeEnrichedPrompt(userInput: string, contextDescription: string, targetConfig: any, capabilities: any): Observable<any>;
+    private formatCapabilities;
+    private normalizeIntentClassification;
+    generateContent(prompt: string, modelName?: string): Observable<string>;
+    generateContentStream(prompt: string, modelName?: string): Observable<string>;
+    generateJson<T>(prompt: string, modelName?: string, schema?: any): Observable<T | null>;
+    isMockMode(): boolean;
+    private extractUserIntent;
+    private getMockPatch;
+    listModels(apiKey?: string): Observable<AiModel[]>;
+    testConnection(apiKey?: string, model?: string): Observable<boolean>;
+    private resolveProvider;
+    private isGeminiProvider;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisAiService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PraxisAiService>;
+}
+
+declare class AiConfigService {
+    private globalConfig;
+    getConfig(): AiIntegrationConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiConfigService>;
+}
+
+interface PatchResult {
+    success: boolean;
+    warnings?: string[];
+    error?: string;
+}
+interface AiSuggestion {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    group?: string;
+    intent: string;
+    score?: number;
+    variantId?: string;
+    patch?: Record<string, unknown> | null;
+    contextHints?: Record<string, unknown> | null;
+    missingContext?: string[];
+}
+/**
+ * Contrato fundamental para qualquer componente que suporte configuração via IA.
+ * O Agente de IA usa esta interface para Ler (Introspecção) e Escrever (Patching) no componente.
+ */
+interface AiConfigAdapter<TConfig = any> {
+    /**
+     * Nome legível do componente para o contexto do prompt (ex: "Data Table").
+     */
+    componentName: string;
+    /**
+     * ID do componente (selector) usado pelo backend AI registry (ex: "praxis-table").
+     */
+    componentId?: string;
+    /**
+     * Tipo lógico do componente para contexto (ex: "table", "form").
+     */
+    componentType?: string;
+    /**
+     * Retorna o objeto de configuração serializável atual.
+     * Usado para que a IA entenda o estado inicial.
+     */
+    getCurrentConfig(): TConfig;
+    /**
+     * Retorna o catálogo de capacidades (o que a IA pode mudar).
+     * Deve ser o conteúdo do arquivo `_ai-capabilities.ts`.
+     */
+    getCapabilities(): Capability[];
+    /**
+     * Retorna exemplos de intenção ou presets de tarefas suportados.
+     * Útil para filtrar capabilities no prompt.
+     * @deprecated Use getSuggestions() for richer context.
+     */
+    getTaskPresets?(): Record<string, string[]>;
+    /**
+     * Retorna sugestões contextuais baseadas na config atual e dados (Heurísticas).
+     * Substitui ou complementa os presets estáticos.
+     */
+    getSuggestions?(forceReload?: boolean): Promise<AiSuggestion[]>;
+    /**
+     * Retorna contexto adicional para geração de sugestões (ex.: recursos disponíveis).
+     */
+    getSuggestionContext?(): Record<string, any>;
+    /**
+     * Retorna o perfil de dados atual (ex.: estatísticas por coluna).
+     * Usado para sugestões determinísticas no backend.
+     */
+    getDataProfile?(): Record<string, any>;
+    /**
+     * Retorna hints de schema por campo (ex.: controlType, numericFormat).
+     * Usado para sugestões heurísticas mais precisas no backend.
+     */
+    getSchemaFields?(): Record<string, any>[];
+    /**
+     * Retorna um snapshot do estado de tempo de execução (volátil).
+     * Ex: { rowCount: 50, isLoading: false, sort: 'name:asc' }.
+     * Usado para responder perguntas do usuário ("Por que está vazio?").
+     */
+    getRuntimeState?(): Record<string, any>;
+    /**
+     * Cria um snapshot do estado atual para fins de Undo.
+     * Retorna um token opaco (pode ser o config JSON completo ou um ID).
+     */
+    createSnapshot(): any;
+    /**
+     * Restaura o estado para um snapshot anterior.
+     */
+    restoreSnapshot(snapshot: any): Promise<void>;
+    /**
+     * Aplica um patch de configuração gerado pela IA.
+     * O Adapter deve validar, mesclar e garantir a reatividade do componente.
+     *
+     * @param patch O JSON parcial gerado pela IA.
+     * @param intent A intenção original do usuário (para logs ou decisões heurísticas).
+     */
+    applyPatch(patch: Partial<TConfig>, intent?: string): Promise<PatchResult>;
+}
+
+declare const AI_STREAM_EVENT_TYPES: readonly ["status", "thought.step", "heartbeat", "result", "error", "cancelled"];
+type AiJsonPrimitive = string | number | boolean | null;
+type AiJsonArray = AiJsonValue[];
+interface AiJsonObject {
+    [key: string]: AiJsonValue;
+}
+type AiJsonValue = AiJsonPrimitive | AiJsonObject | AiJsonArray;
+interface AiSchemaContextContract {
+    path?: string | null;
+    operation?: string | null;
+    schemaType?: string | null;
+}
+interface AiChatMessageContract {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+interface AiUiContextRefContract {
+    componentType?: string | null;
+    componentId?: string | null;
+    routeKey?: string | null;
+    schemaHash?: string | null;
+    variantId?: string | null;
+}
+interface AiCurrentStateDigestContract {
+    columns?: string[] | null;
+    sort?: string | null;
+    rowCount?: number | null;
+}
+interface AiOrchestratorRequestContract {
+    componentId: string;
+    componentType: string;
+    userPrompt?: string;
+    sessionId?: string;
+    mode?: 'new' | 'continue';
+    clientTurnId?: string;
+    messages?: AiChatMessageContract[];
+    summary?: string;
+    uiContextRef?: AiUiContextRefContract;
+    currentStateDigest?: AiCurrentStateDigestContract;
+    currentState: AiJsonObject;
+    dataProfile?: AiJsonObject | null;
+    schemaFields?: AiJsonObject[] | null;
+    runtimeState?: AiJsonObject | null;
+    suggestedPatch?: AiJsonObject | null;
+    contextHints?: AiJsonObject | null;
+    aiMode?: string;
+    requireSchema?: boolean;
+    resourcePath?: string;
+    contractVersion?: string;
+    schemaHash?: string;
+    schemaContext?: AiSchemaContextContract | null;
+    variantId?: string;
+    apiMethod?: string;
+    apiTags?: string;
+    apiSearchLimit?: number;
+}
+type AiOrchestratorResponseType = 'patch' | 'clarification' | 'error' | 'info';
+interface AiPatchDiffContract {
+    path: string;
+    before?: AiJsonValue;
+    after?: AiJsonValue;
+}
+interface AiOptionContract {
+    value?: string | null;
+    label?: string | null;
+    example?: string | null;
+    contextHints?: AiJsonObject | null;
+}
+interface AiClarificationUiContract {
+    responseType?: 'text' | 'choice' | 'confirm' | 'mixed' | 'context';
+    selectionMode?: 'single' | 'multiple';
+    presentation?: 'buttons' | 'list' | 'chips';
+    allowCustom?: boolean | null;
+}
+interface AiMemoryInfoContract {
+    summaryUpdated?: boolean | null;
+    windowSize?: number | null;
+    cached?: boolean | null;
+}
+interface AiOrchestratorResponseContract {
+    sessionId?: string | null;
+    code?: string | null;
+    type?: AiOrchestratorResponseType;
+    contractVersion?: string | null;
+    schemaHash?: string | null;
+    patch?: AiJsonObject | null;
+    diff?: AiPatchDiffContract[] | null;
+    explanation?: string | null;
+    warnings?: string[] | null;
+    message?: string | null;
+    options?: string[] | null;
+    optionPayloads?: AiOptionContract[] | null;
+    contextRequest?: number[] | null;
+    clarification?: AiClarificationUiContract;
+    componentId?: string | null;
+    componentType?: string | null;
+    path?: string | null;
+    providedValue?: AiJsonValue;
+    allowedValues?: string[] | null;
+    memory?: AiMemoryInfoContract;
+}
+interface AiPatchStreamStartResponseContract {
+    streamId: string;
+    threadId: string;
+    turnId: string;
+    eventSchemaVersion: string;
+    streamAuthMode?: 'cookie' | 'signed_url_token' | null;
+    streamAccessToken?: string | null;
+    expiresAt: string;
+    fallbackPatchUrl: string;
+}
+interface AiPatchStreamCancelResponseContract {
+    streamId?: string | null;
+    threadId?: string | null;
+    turnId?: string | null;
+    terminalState: 'cancelled' | 'completed' | 'not_found';
+    message?: string | null;
+}
+interface AiPatchStreamEnvelopeContract<TPayload extends AiJsonObject = AiJsonObject> {
+    eventId?: string | null;
+    streamId: string;
+    threadId: string;
+    turnId: string;
+    seq: number;
+    eventSchemaVersion: string;
+    timestamp: string;
+    type: AiPatchStreamEventType$1;
+    payload: TPayload;
+}
+type AiPatchStreamEventType$1 = (typeof AI_STREAM_EVENT_TYPES)[number];
+
+declare const AI_INTENT_CONTRACT_VERSION: "v1.1";
+declare const AI_INTENT_CONTRACT_SCHEMA_HASH: "51b7901f1df633d89fc019a2e41f675cc5b87b135dfc8335aa96e53205034b26";
+type AiSchemaContext = AiSchemaContextContract;
+interface AiSuggestionsRequest {
+    componentId: string;
+    componentType: string;
+    currentState: AiJsonObject;
+    dataProfile?: AiJsonObject | null;
+    variantId?: string;
+    maxSuggestions?: number;
+    forceRefresh?: boolean;
+    locale?: string;
+}
+interface AiSuggestionsResponse {
+    suggestions: AiSuggestion[];
+    source?: string;
+    cacheKey?: string;
+    cacheHit?: boolean;
+    warnings?: string[];
+}
+type AiOrchestratorRequest = AiOrchestratorRequestContract;
+type AiChatMessage = AiChatMessageContract;
+type AiUiContextRef = AiUiContextRefContract;
+type AiCurrentStateDigest = AiCurrentStateDigestContract;
+type AiPatchDiff = AiPatchDiffContract;
+type AiOrchestratorResponse = AiOrchestratorResponseContract & {
+    riskLevel?: string;
+    requiresConfirmation?: boolean;
+    questions?: string[];
+};
+type AiPatchStreamEventType = AiPatchStreamEventType$1;
+type AiPatchStreamStartResponse = AiPatchStreamStartResponseContract;
+type AiPatchStreamCancelResponse = AiPatchStreamCancelResponseContract;
+type AiPatchStreamEnvelope<TPayload extends AiJsonObject = AiJsonObject> = AiPatchStreamEnvelopeContract<TPayload>;
+interface AiPatchStreamConnection {
+    events$: Observable<AiPatchStreamEnvelope>;
+    close: () => void;
+}
+type AiPatchStreamConnectionErrorKind = 'unsupported' | 'http_status' | 'transport' | 'parse' | 'schema';
+declare class AiPatchStreamConnectionError extends Error {
+    readonly kind: AiPatchStreamConnectionErrorKind;
+    readonly status?: number | undefined;
+    constructor(kind: AiPatchStreamConnectionErrorKind, message: string, status?: number | undefined);
+}
+interface AiProviderModelsRequest {
+    provider?: string;
+    apiKey?: string;
+}
+interface AiProviderModelsResponse {
+    provider?: string;
+    success?: boolean;
+    message?: string;
+    models?: AiModel[];
+}
+interface AiProviderCatalogItem {
+    id: string;
+    label: string;
+    description?: string;
+    defaultModel?: string;
+    requiresApiKey?: boolean;
+    supportsModels?: boolean;
+    supportsEmbeddings?: boolean;
+    supportsTextStreaming?: boolean;
+    supportsTurnCancellation?: boolean;
+    iconKey?: string;
+}
+interface AiProviderCatalogResponse {
+    providers: AiProviderCatalogItem[];
+}
+interface AiProviderTestRequest {
+    provider?: string;
+    apiKey?: string;
+    model?: string;
+}
+interface AiProviderTestResponse {
+    provider?: string;
+    model?: string;
+    success?: boolean;
+    message?: string;
+}
+interface AiProviderStatusResponse {
+    provider?: string;
+    model?: string;
+    hasApiKey?: boolean;
+    source?: string;
+    success?: boolean;
+    message?: string;
+}
+interface AiContextTemplateMeta {
+    variants?: Array<{
+        id?: string;
+        registryKey?: string;
+    } | string>;
+    defaultVariantId?: string;
+}
+interface AiContextTemplate {
+    templateMeta?: AiContextTemplateMeta;
+}
+interface AiContextDTO {
+    componentId?: string;
+    componentType?: string;
+    template?: AiContextTemplate | null;
+}
+interface AiHeaderContext {
+    tenantId: string;
+    env: string;
+    userId: string;
+    missing: string[];
+}
+declare class AiBackendApiService {
+    private readonly http;
+    private readonly globalConfig;
+    private readonly storageOpts;
+    private readonly baseUrl;
+    private readonly contextUrl;
+    getSuggestions(request: AiSuggestionsRequest): Observable<AiSuggestionsResponse>;
+    getPatch(request: AiOrchestratorRequest): Observable<AiOrchestratorResponse>;
+    startPatchStream(request: AiOrchestratorRequest): Observable<AiPatchStreamStartResponse>;
+    connectPatchStream(streamId: string, lastEventId?: string, accessToken?: string): AiPatchStreamConnection;
+    cancelPatchStream(streamId: string, accessToken?: string): Observable<AiPatchStreamCancelResponse>;
+    listModels(request: AiProviderModelsRequest): Observable<AiProviderModelsResponse>;
+    listProviderCatalog(): Observable<AiProviderCatalogResponse>;
+    testProvider(request: AiProviderTestRequest): Observable<AiProviderTestResponse>;
+    getAiStatus(): Observable<AiProviderStatusResponse>;
+    getAiContext(componentId: string, componentType: string): Observable<AiContextDTO>;
+    loadGlobalAiConfig(): Observable<GlobalAiConfig | null>;
+    saveGlobalAiConfig(aiConfig: GlobalAiConfig): Observable<void>;
+    getHeaderContext(): AiHeaderContext;
+    private buildHeaders;
+    private normalizeContractVersion;
+    private normalizeContractSchemaHash;
+    private resolveHeaderMap;
+    private parsePatchStreamEnvelope;
+    private isPatchStreamEnvelope;
+    private isJsonObject;
+    private probePatchStreamEndpoint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiBackendApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiBackendApiService>;
+}
+
+interface FieldSchemaLike {
+    label: string;
+    type: string;
+    description?: string;
+    required?: boolean;
+    uiConfig?: {
+        category?: string;
+    };
+    allowedValues?: Array<{
+        value: any;
+        label: string;
+    }>;
+}
+declare class SchemaMinifierService {
+    /**
+     * Converts complete FieldSchemas into a minified version for AI context (Token optimized)
+     */
+    minify(schemas: Record<string, FieldSchemaLike>): MinifiedField[];
+    /**
+     * Formats minified fields into a string for the AI prompt (Legacy/Text mode)
+     */
+    toPromptFormat(fields: MinifiedField[]): string;
+    /**
+     * Transforms Praxis FieldSchemas into Google Gemini JSON Schema format.
+     * This enables "Response Schema" enforcement in the API.
+     */
+    toGeminiSchema(fields: Record<string, FieldSchemaLike>): Schema;
+    private mapTypeToGemini;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaMinifierService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaMinifierService>;
+}
+
+declare class AiContextBuilderService {
+    private schemaMinifier;
+    constructor(schemaMinifier: SchemaMinifierService);
+    /**
+     * Builds the complete context for the AI prompt
+     */
+    buildPromptContext(fieldSchemas: Record<string, FieldSchemaLike>, targetType: 'field' | 'section' | 'action' | 'row' | 'column', propertySchema: RulePropertySchema): PromptContext;
+    buildRulePrompt(userPrompt: string, context: PromptContext): string;
+    buildSuggestionPrompt(context: PromptContext): string;
+    /**
+     * Formats available properties by targetType
+     */
+    private formatProperties;
+    /**
+     * Lists DSL operators with examples
+     */
+    private formatOperators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiContextBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiContextBuilderService>;
+}
+
+/**
+ * Normalize DSL expression by replacing aliases with standard operators
+ */
+declare function normalizeDsl(dsl: string): string;
+/**
+ * Configuration for parsing DSL expressions
+ */
+interface DslParsingConfig {
+    /** Available function registry */
+    functionRegistry?: FunctionRegistry<any>;
+    /** Context provider for variable resolution */
+    contextProvider?: ContextProvider;
+    /** Known field names for validation */
+    knownFields?: string[];
+    /** Enable performance warnings */
+    enablePerformanceWarnings?: boolean;
+    /** Maximum expression complexity */
+    maxComplexity?: number;
+}
+/**
+ * Result of parsing a DSL expression
+ */
+interface DslParsingResult<T extends object = any> {
+    /** Whether parsing was successful */
+    success: boolean;
+    /** Parsed specification (if successful) */
+    specification?: any;
+    /** Validation issues found */
+    issues: ValidationIssue[];
+    /** Performance metrics */
+    metrics?: {
+        parseTime: number;
+        complexity: number;
+    };
+}
+/**
+ * Dedicated service for DSL parsing and validation
+ * Extracted from SpecificationBridgeService to follow SRP
+ */
+declare class DslParsingService {
+    constructor();
+    /**
+     * Parse a DSL expression into a specification
+     */
+    parseDsl<T extends object = any>(dslExpression: string, config?: DslParsingConfig): DslParsingResult<T>;
+    /**
+     * Normalize DSL expression (delegates to utility)
+     */
+    normalizeDsl(dsl: string): string;
+    /**
+     * Static wrapper for backward compatibility if needed
+     */
+    static normalizeDsl(dsl: string): string;
+    /**
+     * Validate DSL syntax without parsing
+     */
+    validateDsl(dslExpression: string, config?: DslParsingConfig): ValidationIssue[];
+    /**
+     * Get suggestions for DSL completion
+     */
+    getDslSuggestions(partialExpression: string, cursorPosition: number, config?: DslParsingConfig): string[];
+    /**
+     * Format DSL expression for readability
+     */
+    formatDsl(dslExpression: string): string;
+    /**
+     * Check if DSL expression is syntactically valid
+     */
+    isValidDsl(dslExpression: string, config?: DslParsingConfig): boolean;
+    private calculateComplexity;
+    private getCurrentToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DslParsingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DslParsingService>;
+}
+
+interface ValidationContext {
+    fieldSchemas: Record<string, FieldSchemaLike>;
+    targetSchemas?: any;
+    propertySchema: RulePropertySchema;
+}
+declare class AiResponseValidatorService {
+    private dslParsingService;
+    constructor(dslParsingService: DslParsingService);
+    /**
+     * Validates the complete AI response
+     */
+    validate(response: AiRuleResponse, context: ValidationContext): AiValidationResult;
+    private validateStructure;
+    private validateTargetIds;
+    private isValidTargetId;
+    private findSimilarTargetId;
+    private calculateSimilarity;
+    private levenshteinDistance;
+    private validatePropertyType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiResponseValidatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiResponseValidatorService>;
+}
+
+interface AiWizardData {
+    fieldSchemas: Record<string, FieldSchemaLike>;
+    targetSchemas?: any;
+    propertySchema: RulePropertySchema;
+}
+type WizardStep = 'prompt' | 'review';
+declare class AiRuleWizardDialogComponent implements OnInit {
+    dialogRef: MatDialogRef<AiRuleWizardDialogComponent>;
+    data: AiWizardData;
+    private aiService;
+    private validator;
+    private snackBar;
+    private contextBuilder;
+    private cdr;
+    selectedTargetType: 'field' | 'section' | 'action' | 'row' | 'column';
+    userPrompt: string;
+    isGenerating: boolean;
+    validationError: string | null;
+    loadingSuggestions: boolean;
+    suggestions: string[];
+    private suggestionsCache;
+    private suggestionsRequestId;
+    currentStep: WizardStep;
+    generatedResponse: AiRuleResponse | null;
+    warnings: AiValidationWarning[];
+    loadingMessages: string[];
+    currentLoadingMessage: string;
+    streamingText: string;
+    private loadingInterval;
+    constructor(dialogRef: MatDialogRef<AiRuleWizardDialogComponent>, data: AiWizardData, aiService: PraxisAiService, validator: AiResponseValidatorService, snackBar: MatSnackBar, contextBuilder: AiContextBuilderService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    onTargetTypeChange(): void;
+    getAvailableProperties(): _praxisui_core.RulePropertyDefinition[];
+    loadSuggestions(forceRefresh?: boolean): Promise<void>;
+    reloadSuggestions(): void;
+    applySuggestion(text: string): void;
+    generate(): Promise<void>;
+    private startLoadingUX;
+    private stopLoadingUX;
+    backToPrompt(): void;
+    confirm(): void;
+    getProps(obj: any): {
+        key: string;
+        value: any;
+    }[];
+    hasProps(obj: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiRuleWizardDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiRuleWizardDialogComponent, "praxis-ai-rule-wizard-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class StreamingFeedbackComponent {
+    title: string;
+    displayText: string;
+    isThinking: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamingFeedbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StreamingFeedbackComponent, "praxis-ai-streaming-feedback", never, { "title": { "alias": "title"; "required": false; }; "displayText": { "alias": "displayText"; "required": false; }; "isThinking": { "alias": "isThinking"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface ConfigAgentRequest {
+    adapter: AiConfigAdapter;
+    userIntent: string;
+}
+interface ConfigAgentResponse {
+    patch: any;
+    explanation: string;
+    applied: boolean;
+    mockMode: boolean;
+}
+declare class AiConfigAgentService {
+    private ai;
+    constructor(ai: PraxisAiService);
+    isMockMode(): boolean;
+    /**
+     * Legacy single-shot flow: builds a prompt with full config + capabilities.
+     * Two-step flow is preferred (see TableAiAdapter.processUserIntent), but this remains as fallback.
+     */
+    generateConfigPatch(request: ConfigAgentRequest): Promise<ConfigAgentResponse>;
+    private buildPrompt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiConfigAgentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiConfigAgentService>;
+}
+
+/**
+ * Base implementation for AI Adapters.
+ * Provides common validation logic against the Capabilities Catalog.
+ */
+declare abstract class BaseAiAdapter<TConfig = any> implements AiConfigAdapter<TConfig> {
+    abstract componentName: string;
+    abstract getCurrentConfig(): TConfig;
+    abstract getCapabilities(): Capability[];
+    abstract applyPatch(patch: Partial<TConfig>, intent?: string): Promise<PatchResult>;
+    abstract createSnapshot(): any;
+    abstract restoreSnapshot(snapshot: any): Promise<void>;
+    getTaskPresets?(): Record<string, string[]>;
+    getSuggestions(_forceReload?: boolean): Promise<AiSuggestion[]>;
+    getSuggestionContext?(): Record<string, any>;
+    getRuntimeState?(): Record<string, any>;
+    /**
+     * Helper to validate a patch against the capabilities catalog.
+     * Removes keys that are not in the allowed paths.
+     */
+    protected validatePatchAgainstCapabilities(patch: any): any;
+    /**
+     * Helper to check if a patch contains critical changes.
+     */
+    protected getCriticalWarnings(patch: any): string[];
+}
+
+type AssistantMessageRole = 'user' | 'assistant' | 'system';
+interface AssistantHistoryMessage {
+    id: string;
+    role: AssistantMessageRole;
+    text: string;
+    createdAt: string;
+    context?: {
+        componentId?: string;
+        componentType?: string;
+        variantId?: string;
+        suggestionId?: string;
+        usedRag?: boolean;
+    };
+}
+interface AssistantHistorySession {
+    id: string;
+    title: string;
+    tenantId: string;
+    env: string;
+    userId: string;
+    componentId?: string;
+    componentType?: string;
+    serverSessionId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    messages: AssistantHistoryMessage[];
+    summary?: string;
+}
+interface AssistantHistoryContext extends AiHeaderContext {
+    storageAvailable: boolean;
+}
+
+type AssistantState = 'idle' | 'listening' | 'clarification' | 'processing' | 'review' | 'applying' | 'success' | 'error';
+
+interface ClarificationOption {
+    label: string;
+    value: string;
+    example?: string;
+}
+type ClarificationContextHints = AiJsonObject;
+interface ClarificationRichOption extends ClarificationOption {
+    contextHints?: ClarificationContextHints;
+}
+interface PatchPathEdit {
+    path: string;
+    valueText: string;
+    error?: string;
+}
+type RiskPolicy = 'strict' | 'standard';
+type ReviewRiskLevel = 'baixo' | 'médio' | 'alto';
+declare class PraxisAiAssistantComponent implements OnDestroy {
+    adapter: AiConfigAdapter;
+    riskPolicy: RiskPolicy | null;
+    allowManualPatchEdit: boolean;
+    overlayOrigin: CdkOverlayOrigin;
+    triggerButton?: ElementRef<HTMLButtonElement>;
+    inputElement: ElementRef<HTMLInputElement>;
+    state: AssistantState | 'clarification';
+    activeTab: 'task' | 'chat' | 'suggestions';
+    private readonly tabOrder;
+    readonly flowSteps: readonly [{
+        readonly step: 1;
+        readonly label: "Pedido";
+    }, {
+        readonly step: 2;
+        readonly label: "Proposta";
+    }, {
+        readonly step: 3;
+        readonly label: "Impacto";
+    }, {
+        readonly step: 4;
+        readonly label: "Aplicação";
+    }];
+    private taskFlowActive;
+    processingInfoVisible: boolean;
+    isOpen: boolean;
+    loadingSuggestions: boolean;
+    userPrompt: string;
+    aiExplanation: string;
+    pendingPatch: Record<string, unknown> | null;
+    pendingDiff: AiPatchDiff[];
+    patchEditorText: string;
+    patchEditorError: string;
+    patchEditorExpanded: boolean;
+    patchPathEditorExpanded: boolean;
+    patchPathEdits: PatchPathEdit[];
+    patchPathEditorError: string;
+    applyWarnings: string[];
+    lastApplyAt: string | null;
+    lastSnapshot: unknown;
+    errorMsg: string;
+    warnings: string[];
+    private backendRiskLevel;
+    private backendRequiresConfirmation;
+    private effectiveRiskPolicy;
+    suggestionsWarnings: string[];
+    mockMode: boolean;
+    clarificationMessage: string;
+    clarificationOptions: ClarificationRichOption[];
+    clarificationQuestions: string[];
+    clarificationAnswers: string[];
+    clarificationFreeText: string;
+    showManualInput: boolean;
+    private clarificationBasePrompt;
+    private skipClarificationAppend;
+    clarificationResponseType: 'text' | 'choice' | 'confirm' | 'mixed' | 'context';
+    clarificationSelectionMode: 'single' | 'multiple';
+    clarificationAllowCustom: boolean;
+    clarificationPresentation: 'buttons' | 'list' | 'chips';
+    selectedClarificationOptions: ClarificationRichOption[];
+    richSuggestions: AiSuggestion[];
+    private dismissedSuggestionIds;
+    private readonly aiApi;
+    private readonly historyService;
+    private readonly dialog;
+    private readonly cdr;
+    private readonly suggestionsCache;
+    private readonly templateVariantsCache;
+    private activeVariantId;
+    private promptFromSuggestion;
+    private activeSuggestion;
+    private activeContextHints;
+    private activeResourcePath;
+    private activeServerSessionId;
+    private activeStreamId;
+    private activeStreamAccessToken;
+    private activeStreamConnection;
+    private streamSeenEventIds;
+    private streamLastSeqByStream;
+    private streamLastEventIdByStream;
+    private streamLastSeq;
+    private streamLastEventId;
+    private streamTerminalState;
+    private streamTimelineMode;
+    private streamFallbackActive;
+    private streamTimelineStepState;
+    private streamTimelineStepDetail;
+    private currentComponentId;
+    private currentComponentType;
+    private forceNewSession;
+    private readonly sessionStorageAvailable;
+    historyContext: AssistantHistoryContext | null;
+    historyWarnings: string[];
+    historySessions: Array<{
+        id: string;
+        title: string;
+        updatedAt: string;
+        componentId?: string;
+        componentType?: string;
+    }>;
+    activeHistorySession: AssistantHistorySession | null;
+    activeHistoryMessages: AssistantHistoryMessage[];
+    activeHistoryTotalMessages: number;
+    historyExpanded: boolean;
+    historyUndoDeleteSession: AssistantHistorySession | null;
+    private historyUndoTimerId;
+    highlightClarificationDetails: boolean;
+    highlightReviewDetails: boolean;
+    private thoughtDetailsHighlightTimerId;
+    showFullDiff: boolean;
+    private processingStartedAt;
+    private lastProcessingDurationMs;
+    private readonly westernTwoDigitFormatter;
+    private readonly maxHistoryMessages;
+    ngOnDestroy(): void;
+    open(): Promise<void>;
+    close(): void;
+    submitPrompt(overridePrompt?: string): Promise<void>;
+    isTaskMode(): boolean;
+    hasPendingClarification(): boolean;
+    isActiveTab(tab: 'task' | 'chat' | 'suggestions'): boolean;
+    setActiveTab(tab: 'task' | 'chat' | 'suggestions'): void;
+    onTabsKeydown(event: KeyboardEvent): void;
+    private focusTab;
+    getTaskTitle(): string;
+    getTaskSubtitle(): string;
+    getTaskPrimaryLabel(): string;
+    getTaskSecondaryLabel(): string;
+    getTaskCancelLabel(): string;
+    isTaskPrimaryDisabled(): boolean;
+    isBusyState(): boolean;
+    getSystemStatusLabel(): string;
+    getSystemStatusDetail(): string;
+    shouldShowSystemStatusDetail(): boolean;
+    getSystemStatusAriaLive(): 'polite' | 'assertive';
+    shouldShowSnapshotFallbackBadge(): boolean;
+    getRiskPolicyLabel(): string;
+    getRiskPolicyTooltip(): string;
+    isStrictRiskPolicy(): boolean;
+    getFlowStepState(step: number): 'done' | 'active' | 'pending';
+    getFlowStepDetail(step: number): string;
+    shouldShowTaskFlow(): boolean;
+    shouldShowThoughtCard(): boolean;
+    getThoughtTimingLabel(): string;
+    getThoughtSummary(): string;
+    getThoughtPlanTitle(): string;
+    getThoughtChecklist(): string[];
+    openThoughtDetails(): void;
+    openThoughtPreview(): void;
+    getThoughtDetailsTooltip(): string;
+    getThoughtDetailsLabel(): string;
+    getThoughtPreviewTooltip(): string;
+    getThoughtActionHint(): string;
+    shouldShowThoughtPreviewAction(): boolean;
+    shouldShowTaskTimeline(): boolean;
+    getTaskTimelineItems(): Array<{
+        step: number;
+        title: string;
+        detail: string;
+        state: 'done' | 'active' | 'pending';
+    }>;
+    private getThoughtDurationSeconds;
+    private formatDurationClock;
+    private formatWesternTwoDigits;
+    getReviewRiskLevel(): ReviewRiskLevel;
+    getReviewSummary(): string;
+    getDiffToggleLabel(): string;
+    private getReviewChangeCount;
+    private estimatePatchChangeCount;
+    private getCurrentFlowStep;
+    private resolveCurrentFlowStepFromStream;
+    private shouldUseStreamTimeline;
+    private initializeStreamTimeline;
+    private markStreamStep;
+    shouldShowTaskSteps(): boolean;
+    getTaskSelectionSummary(): string | null;
+    getHistorySessionTooltip(session: {
+        componentType?: string;
+        componentId?: string;
+    }): string;
+    getVisibleSuggestions(): AiSuggestion[];
+    hasDismissedSuggestions(): boolean;
+    getDismissedSuggestionCount(): number;
+    restoreDismissedSuggestions(): void;
+    isDatasetSelection(): boolean;
+    hasClarificationSelection(): boolean;
+    confirmTaskAction(): void;
+    handleTaskSecondary(): void;
+    onClarificationOptionClick(opt: ClarificationRichOption): void;
+    toggleManualInput(): void;
+    private toggleClarificationSelection;
+    private setState;
+    private flashThoughtDetails;
+    private clearThoughtDetailsHighlightTimer;
+    private focusTaskPanelTarget;
+    toggleFullDiff(): void;
+    getDiffSummaryLines(): string[];
+    private summarizeDiff;
+    shouldShowApplyDetails(): boolean;
+    getApplyPaths(): string[];
+    getEditablePatchPathEdits(): PatchPathEdit[];
+    togglePatchEditor(): void;
+    resetPatchEditor(): void;
+    togglePatchPathEditor(): void;
+    resetPatchPathEdits(): void;
+    applyPathEditsToPatch(): boolean;
+    reapplyPathEdits(): Promise<void>;
+    reapplyEditedPatch(): Promise<void>;
+    private confirmEditedPatchBeforeApply;
+    getScopeLabel(): string;
+    getScopeTooltip(): string;
+    getConfidenceLabel(): string;
+    getConfidenceTooltip(): string;
+    isClarificationSelected(option: ClarificationRichOption): boolean;
+    getClarificationOptionLayout(option: ClarificationRichOption): 'endpoint' | 'color' | 'description' | 'default';
+    getClarificationOptionKindLabel(option: ClarificationRichOption): string;
+    isEndpointOption(option: ClarificationRichOption): boolean;
+    isColorOption(option: ClarificationRichOption): boolean;
+    hasRichDescription(option: ClarificationRichOption): boolean;
+    getEndpointIcon(option: ClarificationRichOption): string;
+    getEndpointMethod(option: ClarificationRichOption): string | null;
+    getEndpointPath(option: ClarificationRichOption): string | null;
+    shouldShowClarificationTooltip(option: ClarificationRichOption): boolean;
+    getClarificationTooltip(option: ClarificationRichOption): string;
+    getSafeHexColor(option: ClarificationRichOption): string | null;
+    shouldShowDescriptionTooltip(option: ClarificationRichOption): boolean;
+    getDescriptionTooltip(option: ClarificationRichOption): string;
+    shouldShowDescription(option: ClarificationRichOption): boolean;
+    handleClarificationOption(option: ClarificationRichOption | string): Promise<void>;
+    confirmPatch(): Promise<void>;
+    private requiresApplyConfirmation;
+    private confirmRiskApply;
+    private buildRiskConfirmationMessage;
+    private openConfirmationDialog;
+    private normalizeRiskLevel;
+    undoLastChange(): Promise<void>;
+    retry(): void;
+    private applyPatchPayload;
+    private parsePatchEditorText;
+    private collectPatchPaths;
+    private serializePatch;
+    private syncPatchPathEdits;
+    private serializePathValue;
+    private collectEditablePatchPaths;
+    private parsePathEditValue;
+    private getPatchValueAtPath;
+    private setPatchValueAtPath;
+    private tokenizePatchPath;
+    private clonePatch;
+    prepareSuggestionPrompt(sug: AiSuggestion, event?: Event): void;
+    dismissSuggestion(sug: AiSuggestion, event?: Event): void;
+    onSuggestionCardKeydown(event: KeyboardEvent, sug: AiSuggestion): void;
+    selectSuggestion(sug: AiSuggestion): void;
+    refreshSuggestions(): Promise<void>;
+    submitClarificationSelection(): Promise<void>;
+    startNewSession(resetUi?: boolean): void;
+    clearHistory(): Promise<void>;
+    removeHistorySession(sessionId: string, event?: Event): Promise<void>;
+    onHistorySessionCardKeydown(event: KeyboardEvent, sessionId: string): void;
+    reuseHistorySessionPrompt(sessionId: string, event?: Event): void;
+    undoRemoveHistorySession(): void;
+    selectHistorySession(sessionId: string): void;
+    private loadSuggestions;
+    private getPatchViaStreamWithFallback;
+    private consumePatchStream;
+    private applyStreamEvent;
+    private resolveStreamTimeoutMs;
+    private resolveStreamIdleTimeoutMs;
+    private acceptStreamEvent;
+    private resolveLastEventIdForStream;
+    private extractStreamMessage;
+    private requestStreamCancel;
+    private closeActiveStreamConnection;
+    private resetStreamTracking;
+    private shouldFallbackToPatch;
+    private handlePatchResponse;
+    private initHistory;
+    private buildHistoryWarnings;
+    private matchesHistoryContext;
+    private buildClientTurnId;
+    private buildUiContextRef;
+    private buildCurrentStateDigest;
+    private inferAiMode;
+    private resolveRouteKey;
+    private resolveSchemaHash;
+    private checkSessionStorage;
+    private resolveSessionStorageKey;
+    private restoreServerSessionId;
+    private persistServerSessionId;
+    private appendHistoryMessage;
+    private appendHistoryAssistantResponse;
+    private resolveAssistantSummary;
+    private isProcessingMessage;
+    retryProcessing(): Promise<void>;
+    private cancelProcessing;
+    private withSnapshotFallbackDetail;
+    private resolveUsedRag;
+    private sliceHistoryMessages;
+    private applyClarificationUi;
+    private resolveClarificationPresentation;
+    private resetAssistantStateForSession;
+    private setHistoryUndo;
+    private clearPendingHistoryUndo;
+    private clearHistoryUndoTimer;
+    private pruneDismissedSuggestions;
+    private confirmHistoryClear;
+    private enterClarification;
+    private enterClarificationWithOptions;
+    private enterClarificationWithQuestions;
+    private resolveClarificationOptions;
+    private enrichClarification;
+    private buildClarificationAnswers;
+    private needsRuleClarification;
+    private needsValueColorClarification;
+    private needsBadgeValueClarification;
+    private normalizeMissingContext;
+    private resolveBadgeContextHints;
+    private hasBadgeValues;
+    private hasBadgeColors;
+    private hasBadgeField;
+    private mergeContextHints;
+    private setResourcePathHint;
+    private clearResourcePathHint;
+    private matchClarificationOptionPath;
+    private normalizeResourcePath;
+    private extractResourcePath;
+    private asRecord;
+    private toAiJsonObject;
+    private toAiJsonValue;
+    private toClarificationContextHints;
+    private firstNonBlank;
+    private buildRuleClarificationPayloads;
+    private buildValueColorClarificationPayloads;
+    private resolveBadgeValuesContext;
+    private resolveSchemaField;
+    private extractSchemaValues;
+    private extractOptionValueFromSchema;
+    private normalizeOptionKey;
+    private normalizeStringList;
+    private buildValueColorMap;
+    private findColumnInPrompt;
+    private extractOptionValue;
+    private buildMaskSelectionHints;
+    private extractMaskFromText;
+    private resolveComponentId;
+    private resolveComponentType;
+    private buildSuggestionsRequest;
+    private resolveLocale;
+    private resolveConfigRoot;
+    private resolveMockMode;
+    private resolveConfiguredRiskPolicy;
+    private getEffectiveRiskPolicy;
+    private normalizeRiskPolicy;
+    private hasProviderOverride;
+    private resolveMockModeFromStatus;
+    private loadTemplateVariants;
+    private extractVariantIds;
+    private resolveVariantIdForSuggestion;
+    private mapSuggestionToVariantId;
+    private getTemplateVariants;
+    private includesAny;
+    private buildSuggestionsCacheKey;
+    private stableStringify;
+    private hashString;
+    private isTable;
+    private isForm;
+    private extractColumnNames;
+    private extractFieldNames;
+    onKeydown(event: KeyboardEvent): void;
+    private shouldSubmitFromKeydown;
+    private restoreFocusToTrigger;
+    private normalizeError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisAiAssistantComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisAiAssistantComponent, "praxis-ai-assistant", never, { "adapter": { "alias": "adapter"; "required": true; }; "riskPolicy": { "alias": "riskPolicy"; "required": false; }; "allowManualPatchEdit": { "alias": "allowManualPatchEdit"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { AI_INTENT_CONTRACT_SCHEMA_HASH, AI_INTENT_CONTRACT_VERSION, AiBackendApiService, AiConfigAgentService, AiConfigService, AiContextBuilderService, AiPatchStreamConnectionError, AiResponseValidatorService, AiRuleWizardDialogComponent, BaseAiAdapter, DslParsingService, PraxisAi, PraxisAiAssistantComponent, PraxisAiService, SchemaMinifierService, StreamingFeedbackComponent, normalizeDsl };
+export type { AiChatMessage, AiConfigAdapter, AiContextDTO, AiContextTemplate, AiContextTemplateMeta, AiCurrentStateDigest, AiExamplePair, AiHeaderContext, AiIntegrationConfig, AiModel, AiOrchestratorRequest, AiOrchestratorResponse, AiPatchDiff, AiPatchStreamCancelResponse, AiPatchStreamConnection, AiPatchStreamConnectionErrorKind, AiPatchStreamEnvelope, AiPatchStreamEventType, AiPatchStreamStartResponse, AiProviderCatalogItem, AiProviderCatalogResponse, AiProviderModelsRequest, AiProviderModelsResponse, AiProviderStatusResponse, AiProviderTestRequest, AiProviderTestResponse, AiRuleResponse, AiSchemaContext, AiSuggestion, AiSuggestionsRequest, AiSuggestionsResponse, AiUiContextRef, AiValidationError, AiValidationResult, AiValidationWarning, AiWizardData, Capability, ConfigAgentRequest, ConfigAgentResponse, DslParsingConfig, DslParsingResult, FieldSchemaLike, MinifiedField, PatchResult, PromptContext, ValidationContext, ValueKind };