@mcp-consultant-tools/powerplatform 25.0.0 → 26.0.0-beta.3

package/build/PowerPlatformService.d.ts

@@ -1,259 +1,86 @@
-import { type AuthProvider } from './auth/index.js';
-export interface PowerPlatformConfig {
-    organizationUrl: string;
-    clientId: string;
-    /** Client secret is optional - if not provided, interactive auth will be used */
-    clientSecret?: string;
-    tenantId: string;
-}
-export interface ApiCollectionResponse<T> {
-    value: T[];
-    [key: string]: any;
-}
-export interface Violation {
-    attributeLogicalName?: string;
-    attributeType?: string;
-    createdOn?: string;
-    rule: string;
-    severity: 'MUST' | 'SHOULD';
-    message: string;
-    currentValue: string;
-    expectedValue: string;
-    action: string;
-    recommendation?: string;
-}
-export interface EntityValidationResult {
-    logicalName: string;
-    schemaName: string;
-    displayName: string;
-    isRefData: boolean;
-    attributesChecked: number;
-    violations: Violation[];
-    isCompliant: boolean;
-}
-export interface ViolationSummaryByRule {
-    rule: string;
-    severity: 'MUST' | 'SHOULD';
-    totalCount: number;
-    affectedEntities: string[];
-    affectedColumns: string[];
-    action: string;
-    recommendation?: string;
-}
-export interface BestPracticesValidationResult {
-    metadata: {
-        generatedAt: string;
-        solutionName?: string;
-        solutionUniqueName?: string;
-        publisherPrefix: string;
-        recentDays: number;
-        executionTimeMs: number;
-    };
-    summary: {
-        entitiesChecked: number;
-        attributesChecked: number;
-        totalViolations: number;
-        criticalViolations: number;
-        warnings: number;
-        compliantEntities: number;
-    };
-    violationsSummary: ViolationSummaryByRule[];
-    entities: EntityValidationResult[];
-    statistics: {
-        systemColumnsExcluded: number;
-        oldColumnsExcluded: number;
-        refDataTablesSkipped: number;
-    };
-}
-export interface FlowFilterOptions {
-    activeOnly?: boolean;
-    maxRecords?: number;
-    excludeCustomerInsights?: boolean;
-    excludeSystem?: boolean;
-    excludeCopilotSales?: boolean;
-    nameContains?: string;
-}
-export interface FlowListResult {
-    totalCount: number;
-    hasMore: boolean;
-    requestedMax: number;
-    excluded: {
-        customerInsights: number;
-        system: number;
-        copilotSales: number;
-        total: number;
-    };
-    filterApplied: {
-        excludeCustomerInsights: boolean;
-        excludeSystem: boolean;
-        excludeCopilotSales: boolean;
-        nameContains?: string;
-    };
-    flows: FlowSummary[];
-}
-export interface FlowSummary {
-    workflowid: string;
-    name: string;
-    description: string | null;
-    state: string;
-    statecode: number;
-    statuscode: number;
-    type: string;
-    primaryEntity: string | null;
-    isManaged: boolean;
-    ownerId: string;
-    modifiedOn: string;
-    modifiedBy: string | null;
-    createdOn: string;
-}
+/**
+ * PowerPlatformService - Slim Read-Only Facade
+ *
+ * This is a facade that delegates to services in @mcp-consultant-tools/powerplatform-core.
+ * It provides READ-ONLY access to PowerPlatform/Dataverse entities.
+ *
+ * For data CRUD operations, use @mcp-consultant-tools/powerplatform-data.
+ * For customization operations, use @mcp-consultant-tools/powerplatform-customization.
+ */
+import { type PowerPlatformConfig, type ApiCollectionResponse, type FlowFilterOptions, type FlowListResult, type FlowSummary, type BestPracticesValidationResult, type AuthProvider } from '@mcp-consultant-tools/powerplatform-core';
+export type { PowerPlatformConfig, ApiCollectionResponse, FlowFilterOptions, FlowListResult, FlowSummary, BestPracticesValidationResult, };
 export declare class PowerPlatformService {
-    private config;
-    private authProvider;
-    private environmentId;
+    private client;
+    private metadata;
+    private plugin;
+    private flow;
+    private workflow;
+    private businessRule;
+    private app;
+    private validation;
+    private form;
+    private view;
+    private webResource;
+    private solution;
+    private dependency;
+    private publishing;
+    private relationship;
     constructor(config: PowerPlatformConfig, authProvider?: AuthProvider);
-    /**
-     * Get the authentication mode being used
-     */
     getAuthMode(): 'service-principal' | 'interactive';
-    /**
-     * Get information about the authenticated user (if using interactive auth)
-     */
     getUserInfo(): Promise<{
         name: string;
         email: string;
         oid: string;
     } | null>;
-    /**
-     * Clear cached tokens (logout) - only applicable for interactive auth
-     */
     logout(): Promise<void>;
-    /**
-     * Get an access token for the PowerPlatform API
-     */
-    private getAccessToken;
-    /**
-     * Make an authenticated request to the PowerPlatform API
-     * Extended to support all HTTP methods for write operations
-     */
-    private makeRequest;
-    /**
-     * Get metadata about an entity
-     * @param entityName The logical name of the entity
-     */
-    getEntityMetadata(entityName: string): Promise<any>;
-    /**
-     * Get metadata about entity attributes/fields
-     * @param entityName The logical name of the entity
-     */
+    getEntityMetadata(entityName: string): Promise<unknown>;
     getEntityAttributes(entityName: string, options?: {
         prefix?: string;
         attributeType?: string;
         maxAttributes?: number;
     }): Promise<{
-        value: any[];
+        value: unknown[];
         hasMore: boolean;
         returnedCount: number;
         totalBeforeFilter?: number;
     }>;
-    /**
-     * Get metadata about a specific entity attribute/field
-     * @param entityName The logical name of the entity
-     * @param attributeName The logical name of the attribute
-     */
-    getEntityAttribute(entityName: string, attributeName: string): Promise<any>;
-    /**
-     * Get one-to-many relationships for an entity
-     * @param entityName The logical name of the entity
-     */
-    getEntityOneToManyRelationships(entityName: string): Promise<ApiCollectionResponse<any>>;
-    /**
-     * Get many-to-many relationships for an entity
-     * @param entityName The logical name of the entity
-     */
-    getEntityManyToManyRelationships(entityName: string): Promise<ApiCollectionResponse<any>>;
-    /**
-     * Get all relationships (one-to-many and many-to-many) for an entity
-     * @param entityName The logical name of the entity
-     */
+    getEntityAttribute(entityName: string, attributeName: string): Promise<unknown>;
     getEntityRelationships(entityName: string): Promise<{
-        oneToMany: ApiCollectionResponse<any>;
-        manyToMany: ApiCollectionResponse<any>;
+        oneToMany: ApiCollectionResponse<unknown>;
+        manyToMany: ApiCollectionResponse<unknown>;
     }>;
-    /**
-     * Get a global option set definition by name
-     * @param optionSetName The name of the global option set
-     * @returns The global option set definition
-     */
-    getGlobalOptionSet(optionSetName: string): Promise<any>;
-    /**
-     * Get a specific record by entity name (plural) and ID
-     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
-     * @param recordId The GUID of the record
-     * @returns The record data
-     */
-    getRecord(entityNamePlural: string, recordId: string): Promise<any>;
-    /**
-     * Query records using entity name (plural) and a filter expression
-     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
-     * @param filter OData filter expression (e.g., "name eq 'test'")
-     * @param maxRecords Maximum number of records to retrieve (default: 50)
-     * @returns Filtered list of records
-     */
-    queryRecords(entityNamePlural: string, filter: string, maxRecords?: number, select?: string[]): Promise<{
-        value: any[];
+    getGlobalOptionSet(optionSetName: string): Promise<unknown>;
+    getGlobalOptionSets(options?: {
+        maxRecords?: number;
+        prefix?: string;
+    }): Promise<{
+        value: unknown[];
         hasMore: boolean;
-        returnedCount: number;
-        requestedMax: number;
+        totalCount: number;
+    }>;
+    getPluginAssemblies(includeManaged?: boolean, maxRecords?: number): Promise<{
+        totalCount: number;
+        assemblies: unknown[];
+    }>;
+    getPluginAssemblyComplete(assemblyName: string, includeDisabled?: boolean): Promise<{
+        assembly: unknown;
+        pluginTypes: unknown[];
+        steps: unknown[];
+        validation: {
+            hasDisabledSteps: boolean;
+            hasAsyncSteps: boolean;
+            hasSyncSteps: boolean;
+            stepsWithoutFilteringAttributes: string[];
+            stepsWithoutImages: string[];
+            potentialIssues: string[];
+        };
+    }>;
+    getEntityPluginPipeline(entityName: string, messageFilter?: string, includeDisabled?: boolean): Promise<{
+        entity: string;
+        messages: unknown[];
+        steps: unknown[];
+        executionOrder: string[];
     }>;
-    /**
-     * Create a new record in Dataverse
-     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
-     * @param data Record data as JSON object (field names must match logical names)
-     * @returns Created record with ID and OData context
-     */
-    createRecord(entityNamePlural: string, data: Record<string, any>): Promise<any>;
-    /**
-     * Update an existing record in Dataverse
-     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
-     * @param recordId The GUID of the record to update
-     * @param data Partial record data to update (only fields being changed)
-     * @returns Updated record (if Prefer header used) or void
-     */
-    updateRecord(entityNamePlural: string, recordId: string, data: Record<string, any>): Promise<any>;
-    /**
-     * Delete a record from Dataverse
-     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
-     * @param recordId The GUID of the record to delete
-     * @returns Void (successful deletion returns 204 No Content)
-     */
-    deleteRecord(entityNamePlural: string, recordId: string): Promise<void>;
-    /**
-     * Get all plugin assemblies in the environment
-     * @param includeManaged Include managed assemblies (default: false)
-     * @param maxRecords Maximum number of assemblies to return (default: 100)
-     * @returns List of plugin assemblies with basic information
-     */
-    getPluginAssemblies(includeManaged?: boolean, maxRecords?: number): Promise<any>;
-    /**
-     * Get a plugin assembly by name with all related plugin types, steps, and images
-     * @param assemblyName The name of the plugin assembly
-     * @param includeDisabled Include disabled steps (default: false)
-     * @returns Complete plugin assembly information with validation
-     */
-    getPluginAssemblyComplete(assemblyName: string, includeDisabled?: boolean): Promise<any>;
-    /**
-     * Get all plugins that execute on a specific entity, organized by message and execution order
-     * @param entityName The logical name of the entity
-     * @param messageFilter Optional filter by message name (e.g., "Create", "Update")
-     * @param includeDisabled Include disabled steps (default: false)
-     * @returns Complete plugin pipeline for the entity
-     */
-    getEntityPluginPipeline(entityName: string, messageFilter?: string, includeDisabled?: boolean): Promise<any>;
-    /**
-     * Get plugin trace logs with filtering
-     * @param options Filtering options for trace logs
-     * @returns Filtered trace logs with parsed exception details
-     */
     getPluginTraceLogs(options: {
         entityName?: string;
         messageName?: string;
@@ -262,23 +89,11 @@ export declare class PowerPlatformService {
         exceptionOnly?: boolean;
         hoursBack?: number;
         maxRecords?: number;
-    }): Promise<any>;
-    private getOperationTypeName;
-    private extractExceptionType;
-    private extractExceptionMessage;
-    /**
-     * Get Power Automate cloud flows with smart filtering
-     * By default, excludes non-custom flows (CXP_, SYSTEM, Copilot for Sales) to reduce noise.
-     * @param options Filter options for flows
-     * @returns FlowListResult with flows and exclusion statistics
-     */
+    }): Promise<{
+        totalCount: number;
+        logs: unknown[];
+    }>;
     getFlows(options?: FlowFilterOptions): Promise<FlowListResult>;
-    /**
-     * Search workflows (both classic workflows and Power Automate flows)
-     * Supports flexible filtering by name, entity, description, category, and state
-     * @param options Search filter options
-     * @returns Array of matching workflows with metadata
-     */
     searchWorkflows(options?: {
         name?: string;
         primaryEntity?: string;
@@ -291,517 +106,65 @@ export declare class PowerPlatformService {
         totalCount: number;
         hasMore: boolean;
         requestedMax: number;
-        workflows: any[];
+        workflows: unknown[];
+    }>;
+    getFlowDefinition(flowId: string, summary?: boolean): Promise<unknown>;
+    getFlowRuns(flowId: string, maxRecords?: number): Promise<{
+        flowId: string;
+        totalCount: number;
+        runs: unknown[];
+    }>;
+    getFlowRunDetails(flowId: string, runId: string): Promise<unknown>;
+    getWorkflows(activeOnly?: boolean, maxRecords?: number): Promise<{
+        totalCount: number;
+        hasMore: boolean;
+        requestedMax: number;
+        workflows: unknown[];
+    }>;
+    getWorkflowDefinition(workflowId: string, summary?: boolean): Promise<unknown>;
+    getBusinessRules(activeOnly?: boolean, maxRecords?: number): Promise<{
+        totalCount: number;
+        businessRules: unknown[];
+    }>;
+    getBusinessRule(workflowId: string): Promise<unknown>;
+    getApps(activeOnly?: boolean, maxRecords?: number, includeUnpublished?: boolean, solutionUniqueName?: string): Promise<{
+        totalCount: number;
+        apps: unknown[];
+        filters: {
+            activeOnly: boolean;
+            includeUnpublished: boolean;
+            solutionUniqueName: string;
+        };
     }>;
-    /**
-     * Get a specific Power Automate flow with its complete definition
-     * @param flowId The GUID of the flow (workflowid)
-     * @returns Complete flow information including the flow definition JSON
-     */
-    getFlowDefinition(flowId: string, summary?: boolean): Promise<any>;
-    /**
-     * Parse a flow definition to extract a summary
-     * @param flowDef The parsed flow definition JSON
-     * @returns Summary object with trigger, actions, and connectors
-     */
-    parseFlowSummary(flowDef: any): any;
-    /**
-     * Get flow run history for a specific Power Automate flow
-     * @param flowId The GUID of the flow (workflowid)
-     * @param maxRecords Maximum number of runs to return (default: 100)
-     * @returns List of flow runs with status, start time, duration, and error details
-     */
-    getFlowRuns(flowId: string, maxRecords?: number): Promise<any>;
-    /**
-     * Extract environment ID from organization URL
-     * @returns Environment ID (GUID)
-     */
-    private getEnvironmentId;
-    /**
-     * Get an access token for the Power Automate Management API
-     * @returns Access token for management.azure.com
-     */
-    private getFlowManagementToken;
-    /**
-     * Get detailed flow run information including action-level execution details
-     * @param flowId The GUID of the flow (workflowid)
-     * @param runId The GUID of the flow run (flowrunid)
-     * @returns Detailed flow run information with action-level execution data
-     */
-    getFlowRunDetails(flowId: string, runId: string): Promise<any>;
-    /**
-     * Get all classic Dynamics workflows in the environment
-     * @param activeOnly Only return activated workflows (default: false)
-     * @param maxRecords Maximum number of workflows to return (default: 100)
-     * @returns List of classic workflows with basic information
-     */
-    getWorkflows(activeOnly?: boolean, maxRecords?: number): Promise<any>;
-    /**
-     * Get a specific classic workflow with its complete XAML definition
-     * @param workflowId The GUID of the workflow (workflowid)
-     * @param summary If true, parse XAML and return structured summary instead of raw XAML
-     * @returns Complete workflow information including the XAML definition or parsed summary
-     */
-    getWorkflowDefinition(workflowId: string, summary?: boolean): Promise<any>;
-    /**
-     * Parse workflow XAML to extract a structured summary
-     * @param xaml The raw XAML string
-     * @returns Summary object with activities, conditions, and variables
-     */
-    parseWorkflowXamlSummary(xaml: string | null): any;
-    /**
-     * Get all business rules in the environment
-     * @param activeOnly Only return activated business rules (default: false)
-     * @param maxRecords Maximum number of business rules to return (default: 100)
-     * @returns List of business rules with basic information
-     */
-    getBusinessRules(activeOnly?: boolean, maxRecords?: number): Promise<any>;
-    /**
-     * Get a specific business rule with its complete XAML definition
-     * @param workflowId The GUID of the business rule (workflowid)
-     * @returns Complete business rule information including the XAML definition
-     */
-    getBusinessRule(workflowId: string): Promise<any>;
-    /**
-     * Get all model-driven apps in the environment
-     * @param activeOnly Only return active apps (default: false)
-     * @param maxRecords Maximum number of apps to return (default: 100)
-     * @returns List of model-driven apps with basic information
-     */
-    getApps(activeOnly?: boolean, maxRecords?: number, includeUnpublished?: boolean, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Get a specific model-driven app by ID
-     * @param appId The GUID of the app (appmoduleid)
-     * @returns Complete app information including publisher details
-     */
-    getApp(appId: string): Promise<any>;
-    /**
-     * Get all components (entities, forms, views, sitemaps) associated with an app
-     * @param appId The GUID of the app (appmoduleid)
-     * @returns List of app components with type information
-     */
-    getAppComponents(appId: string): Promise<any>;
-    /**
-     * Get the sitemap for a specific app
-     * @param appId The GUID of the app (appmoduleid)
-     * @returns Sitemap information including XML
-     */
-    getAppSitemap(appId: string): Promise<any>;
-    /**
-     * Create a new model-driven app
-     * @param appDefinition The app definition object
-     * @param solutionUniqueName Optional solution to add the app to
-     * @returns The created app information including ID
-     */
-    createApp(appDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Create a sitemap from simplified configuration (no XML knowledge required)
-     * @param config Simplified sitemap configuration
-     * @param solutionUniqueName Optional solution to add the sitemap to
-     * @returns The created sitemap information including ID and XML
-     */
-    createSimpleSitemap(config: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Add entities to an app by modifying the sitemap XML
-     * @param appId The GUID of the app
-     * @param entityNames Array of entity logical names to add
-     * @returns Result of the operation
-     */
-    addEntitiesToApp(appId: string, entityNames: string[]): Promise<any>;
-    /**
-     * Validate an app before publishing
-     * @param appId The GUID of the app
-     * @returns Validation result with any issues found
-     */
-    validateApp(appId: string): Promise<any>;
-    /**
-     * Publish an app to make it available to users
-     * @param appId The GUID of the app
-     * @returns Result of the publish operation
-     */
-    publishApp(appId: string): Promise<any>;
-    /**
-     * Helper to escape XML special characters
-     */
-    private escapeXml;
-    /**
-     * Create a new custom entity (table)
-     * @param entityDefinition The entity definition object
-     * @param solutionUniqueName Optional solution to add the entity to
-     * @returns The created entity metadata
-     */
-    createEntity(entityDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Update an existing entity
-     * @param metadataId The MetadataId of the entity
-     * @param updates The properties to update
-     * @param solutionUniqueName Optional solution context
-     */
-    updateEntity(metadataId: string, updates: any, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Delete a custom entity
-     * @param metadataId The MetadataId of the entity to delete
-     */
-    deleteEntity(metadataId: string): Promise<void>;
-    /**
-     * Update entity icon using Fluent UI System Icon
-     * @param entityLogicalName The logical name of the entity
-     * @param iconFileName The Fluent UI icon file name (e.g., 'people_community_24_filled.svg')
-     * @param solutionUniqueName Optional solution to add the web resource to
-     * @returns Result with web resource ID and icon vector name
-     */
-    updateEntityIcon(entityLogicalName: string, iconFileName: string, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Create a new attribute on an entity
-     * @param entityLogicalName The logical name of the entity
-     * @param attributeDefinition The attribute definition object
-     * @param solutionUniqueName Optional solution to add the attribute to
-     * @returns The created attribute metadata
-     */
-    createAttribute(entityLogicalName: string, attributeDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Update an existing attribute
-     * @param entityLogicalName The logical name of the entity
-     * @param attributeLogicalName The logical name of the attribute
-     * @param updates The properties to update
-     * @param solutionUniqueName Optional solution context
-     */
-    updateAttribute(entityLogicalName: string, attributeLogicalName: string, updates: any, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Delete an attribute
-     * @param entityLogicalName The logical name of the entity
-     * @param attributeMetadataId The MetadataId of the attribute to delete
-     */
-    deleteAttribute(entityLogicalName: string, attributeMetadataId: string): Promise<void>;
-    /**
-     * Create a picklist attribute using a global option set
-     * @param entityLogicalName The logical name of the entity
-     * @param attributeDefinition The attribute definition (must reference a global option set)
-     * @param solutionUniqueName Optional solution to add the attribute to
-     * @returns The created attribute metadata
-     */
-    createGlobalOptionSetAttribute(entityLogicalName: string, attributeDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Create a one-to-many relationship
-     * @param relationshipDefinition The relationship definition
-     * @param solutionUniqueName Optional solution to add the relationship to
-     */
-    createOneToManyRelationship(relationshipDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Create a many-to-many relationship
-     * @param relationshipDefinition The relationship definition
-     * @param solutionUniqueName Optional solution to add the relationship to
-     */
-    createManyToManyRelationship(relationshipDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Delete a relationship
-     * @param metadataId The MetadataId of the relationship to delete
-     */
-    deleteRelationship(metadataId: string): Promise<void>;
-    /**
-     * Update a relationship
-     * Note: Most relationship properties are immutable, only labels can be updated
-     * @param metadataId The MetadataId of the relationship
-     * @param updates The properties to update (typically labels)
-     */
-    updateRelationship(metadataId: string, updates: any): Promise<void>;
-    /**
-     * Get detailed information about a relationship
-     * @param metadataId The MetadataId of the relationship
-     * @returns The relationship metadata
-     */
-    getRelationshipDetails(metadataId: string): Promise<any>;
-    /**
-     * Publish all customizations
-     */
-    publishAllCustomizations(): Promise<void>;
-    /**
-     * Publish specific customizations
-     * @param parameterXml The ParameterXml specifying what to publish
-     */
-    publishXml(parameterXml: string): Promise<void>;
-    /**
-     * Create a global option set
-     * @param optionSetDefinition The option set definition
-     * @param solutionUniqueName Optional solution to add the option set to
-     */
-    createGlobalOptionSet(optionSetDefinition: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Delete a global option set
-     * @param metadataId The MetadataId of the option set to delete
-     */
-    deleteGlobalOptionSet(metadataId: string): Promise<void>;
-    /**
-     * Update a global option set
-     */
-    updateGlobalOptionSet(metadataId: string, updates: any, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Add a value to a global option set
-     */
-    addOptionSetValue(optionSetName: string, value: number, label: string, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Update an option set value
-     */
-    updateOptionSetValue(optionSetName: string, value: number, label: string, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Delete an option set value
-     */
-    deleteOptionSetValue(optionSetName: string, value: number): Promise<void>;
-    /**
-     * Reorder option set values
-     */
-    reorderOptionSetValues(optionSetName: string, values: number[], solutionUniqueName?: string): Promise<void>;
-    /**
-     * Create a form (systemform)
-     */
-    createForm(form: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Update a form
-     */
-    updateForm(formId: string, updates: any, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Delete a form
-     */
-    deleteForm(formId: string): Promise<void>;
-    /**
-     * Get forms for an entity
-     */
-    getForms(entityLogicalName: string): Promise<any>;
-    /**
-     * Create a view (savedquery)
-     */
-    createView(view: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Update a view
-     */
-    updateView(viewId: string, updates: any, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Delete a view
-     */
-    deleteView(viewId: string): Promise<void>;
-    /**
-     * Get views for an entity
-     */
-    getViews(entityLogicalName: string): Promise<any>;
-    /**
-     * Activate a form (set statecode=1)
-     * @param formId The systemformid (GUID)
-     */
-    activateForm(formId: string): Promise<void>;
-    /**
-     * Deactivate a form (set statecode=0)
-     * @param formId The systemformid (GUID)
-     */
-    deactivateForm(formId: string): Promise<void>;
-    /**
-     * Set a view as the default view for its entity
-     * @param viewId The savedqueryid (GUID)
-     */
-    setDefaultView(viewId: string): Promise<void>;
-    /**
-     * Get the FetchXML from a view
-     * @param viewId The savedqueryid (GUID)
-     * @returns The view with FetchXML
-     */
-    getViewFetchXml(viewId: string): Promise<any>;
-    /**
-     * Create a web resource
-     */
-    createWebResource(webResource: any, solutionUniqueName?: string): Promise<any>;
-    /**
-     * Update a web resource
-     */
-    updateWebResource(webResourceId: string, updates: any, solutionUniqueName?: string): Promise<void>;
-    /**
-     * Delete a web resource
-     */
-    deleteWebResource(webResourceId: string): Promise<void>;
-    /**
-     * Get web resource
-     */
-    getWebResource(webResourceId: string): Promise<any>;
-    /**
-     * Get web resources by name pattern
-     */
-    getWebResources(nameFilter?: string): Promise<any>;
-    /**
-     * Get web resource content (base64 encoded)
-     * @param webResourceId The webresourceid (GUID)
-     * @returns The web resource with content field
-     */
-    getWebResourceContent(webResourceId: string): Promise<any>;
-    /**
-     * Get web resource dependencies
-     * @param webResourceId The webresourceid (GUID)
-     * @returns List of dependencies
-     */
-    getWebResourceDependencies(webResourceId: string): Promise<any>;
-    /**
-     * Create a publisher
-     */
-    createPublisher(publisher: any): Promise<any>;
-    /**
-     * Get publishers
-     */
-    getPublishers(): Promise<any>;
-    /**
-     * Create a solution
-     */
-    createSolution(solution: any): Promise<any>;
-    /**
-     * Get solutions
-     */
-    getSolutions(): Promise<any>;
-    /**
-     * Get solution by unique name
-     */
-    getSolution(uniqueName: string): Promise<any>;
-    /**
-     * Add component to solution
-     */
-    addComponentToSolution(solutionUniqueName: string, componentId: string, componentType: number, addRequiredComponents?: boolean, includedComponentSettingsValues?: string): Promise<void>;
-    /**
-     * Remove component from solution
-     */
-    removeComponentFromSolution(solutionUniqueName: string, componentId: string, componentType: number): Promise<void>;
-    /**
-     * Get solution components
-     */
-    getSolutionComponents(solutionUniqueName: string): Promise<any>;
-    /**
-     * Export solution
-     */
-    exportSolution(solutionName: string, managed?: boolean): Promise<any>;
-    /**
-     * Import solution
-     */
-    importSolution(customizationFile: string, publishWorkflows?: boolean, overwriteUnmanagedCustomizations?: boolean): Promise<any>;
-    /**
-     * Delete a solution
-     */
-    deleteSolution(solutionId: string): Promise<void>;
-    /**
-     * Publish specific entity
-     */
-    publishEntity(entityLogicalName: string): Promise<void>;
-    /**
-     * Publish specific component
-     */
-    publishComponent(componentId: string, componentType: number): Promise<void>;
-    /**
-     * Check for unpublished customizations
-     */
-    checkUnpublishedChanges(): Promise<any>;
-    /**
-     * Check component dependencies
-     */
-    checkDependencies(componentId: string, componentType: number): Promise<any>;
-    /**
-     * Check if component can be deleted
-     */
+    getApp(appId: string): Promise<unknown>;
+    getAppComponents(appId: string): Promise<{
+        totalCount: number;
+        components: unknown[];
+        groupedByType: Record<string, unknown[]>;
+    }>;
+    getAppSitemap(appId: string): Promise<unknown>;
+    getForms(entityLogicalName: string): Promise<unknown>;
+    getViews(entityLogicalName: string): Promise<unknown>;
+    getViewFetchXml(viewId: string): Promise<unknown>;
+    getWebResource(webResourceId: string): Promise<unknown>;
+    getWebResources(nameFilter?: string): Promise<unknown>;
+    getWebResourceDependencies(webResourceId: string): Promise<unknown>;
+    getPublishers(): Promise<unknown>;
+    getSolutions(): Promise<unknown>;
+    getSolution(uniqueName: string): Promise<unknown>;
+    getSolutionComponents(solutionUniqueName: string): Promise<unknown>;
+    checkDependencies(componentId: string, componentType: number): Promise<unknown>;
     checkDeleteEligibility(componentId: string, componentType: number): Promise<{
         canDelete: boolean;
-        dependencies: any[];
+        dependencies: unknown[];
     }>;
-    /**
-     * Preview unpublished changes
-     * Returns all components that have unpublished customizations
-     */
-    previewUnpublishedChanges(): Promise<any>;
-    /**
-     * Check dependencies for a specific component
-     * @param componentId The component ID (GUID)
-     * @param componentType The component type code
-     * @returns Dependency information
-     */
-    checkComponentDependencies(componentId: string, componentType: number): Promise<any>;
-    /**
-     * Validate solution integrity
-     * Checks for missing dependencies and other issues
-     * @param solutionUniqueName The unique name of the solution
-     * @returns Validation results
-     */
-    validateSolutionIntegrity(solutionUniqueName: string): Promise<any>;
-    /**
-     * Validate schema name
-     */
+    checkComponentDependencies(componentId: string, componentType: number): Promise<unknown>;
+    checkUnpublishedChanges(): Promise<unknown>;
+    previewUnpublishedChanges(): Promise<unknown>;
+    validateBestPractices(solutionUniqueName: string | undefined, entityLogicalNames: string[] | undefined, publisherPrefix: string, recentDays?: number, includeRefDataTables?: boolean, rules?: string[], maxEntities?: number, requiredColumns?: string[]): Promise<BestPracticesValidationResult>;
     validateSchemaName(schemaName: string, prefix: string): {
         valid: boolean;
         errors: string[];
     };
-    /**
-     * Get entity customization information
-     */
-    getEntityCustomizationInfo(entityLogicalName: string): Promise<any>;
-    /**
-     * Check if entity has dependencies
-     */
-    checkEntityDependencies(entityLogicalName: string): Promise<any>;
-    /**
-     * Helper to generate GUID
-     */
-    private generateGuid;
-    /**
-     * Validate Dataverse entities against best practices
-     * @param solutionUniqueName - Solution unique name (mutually exclusive with entityLogicalNames)
-     * @param entityLogicalNames - Explicit list of entities to validate (mutually exclusive with solutionUniqueName)
-     * @param publisherPrefix - Publisher prefix to validate against (e.g., 'sic_')
-     * @param recentDays - Only validate columns created in last N days (0 = all columns)
-     * @param includeRefDataTables - Include RefData tables in validation
-     * @param rules - Specific rules to validate
-     * @param maxEntities - Maximum number of entities to validate (0 = unlimited)
-     * @returns Structured validation results with violations
-     */
-    validateBestPractices(solutionUniqueName: string | undefined, entityLogicalNames: string[] | undefined, publisherPrefix: string, recentDays?: number, includeRefDataTables?: boolean, rules?: string[], maxEntities?: number, requiredColumns?: string[]): Promise<BestPracticesValidationResult>;
-    /**
-     * Helper method to validate entity-level properties and attributes against best practice rules
-     */
-    private validateEntityAndAttributes;
-    /**
-     * Build violations summary with complete lists of affected entities and columns grouped by rule
-     * @private
-     */
-    private buildViolationsSummary;
-    /**
-     * Find automations with YAML metadata indicating they modify a specific table
-     * Fast server-side search using OData contains() filter
-     */
-    findDocumentedAutomationsByTable(tableName: string, options?: {
-        includeFlows?: boolean;
-        includeWorkflows?: boolean;
-        activeOnly?: boolean;
-    }): Promise<{
-        matches: Array<{
-            id: string;
-            name: string;
-            type: 'flow' | 'workflow';
-            tablesModified: string[];
-            trigger: string;
-            description: string;
-        }>;
-        undocumentedCount: number;
-        searchedCount: number;
-    }>;
-    /**
-     * Deep analysis of automations lacking YAML metadata
-     * Fetches and parses definitions to find which tables they modify
-     */
-    analyzeUndocumentedAutomations(tableName: string, options?: {
-        includeFlows?: boolean;
-        includeWorkflows?: boolean;
-        activeOnly?: boolean;
-        maxToAnalyze?: number;
-    }): Promise<{
-        matches: Array<{
-            id: string;
-            name: string;
-            type: 'flow' | 'workflow';
-            tablesModified: string[];
-            trigger: string;
-            documented: false;
-        }>;
-        analyzedCount: number;
-        skippedCount: number;
-    }>;
 }
 //# sourceMappingURL=PowerPlatformService.d.ts.map