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

package/build/PowerPlatformService.js

@@ -1,3312 +1,585 @@
-import { ConfidentialClientApplication } from '@azure/msal-node';
-import axios from 'axios';
-import { bestPracticesValidator } from './utils/bestPractices.js';
-import { iconManager } from './utils/iconManager.js';
-import { auditLogger } from '@mcp-consultant-tools/core';
-import { rateLimiter } from './utils/rate-limiter.js';
-import { PowerPlatformService as PowerPlatformReadOnlyService } from '@mcp-consultant-tools/powerplatform';
+/**
+ * PowerPlatformService - Slim Customization Facade
+ *
+ * This is a facade that delegates to services in @mcp-consultant-tools/powerplatform-core.
+ * It provides CUSTOMIZATION operations for PowerPlatform/Dataverse entities.
+ *
+ * For read-only operations, use @mcp-consultant-tools/powerplatform.
+ * For data CRUD operations, use @mcp-consultant-tools/powerplatform-data.
+ */
+import { 
+// Client and types
+PowerPlatformClient, 
+// Read-only services (needed for inspecting before customizing)
+MetadataService, PluginService, FlowService, WorkflowService, BusinessRuleService, AppService, ValidationService, 
+// Customization services
+EntityService, AttributeService, RelationshipService, OptionSetService, FormService, ViewService, WebResourceService, SolutionService, PublishingService, DependencyService, PluginDeploymentService, AppManagementService, WorkflowManagementService, createAuthProvider, } from '@mcp-consultant-tools/powerplatform-core';
 export class PowerPlatformService {
-    config;
-    msalClient;
-    accessToken = null;
-    tokenExpirationTime = 0;
-    constructor(config) {
-        this.config = config;
-        // Initialize MSAL client
-        this.msalClient = new ConfidentialClientApplication({
-            auth: {
-                clientId: this.config.clientId,
-                clientSecret: this.config.clientSecret,
-                authority: `https://login.microsoftonline.com/${this.config.tenantId}`,
-            }
-        });
-    }
-    /**
-     * Get an access token for the PowerPlatform API
-     */
-    async getAccessToken() {
-        const currentTime = Date.now();
-        // If we have a token that isn't expired, return it
-        if (this.accessToken && this.tokenExpirationTime > currentTime) {
-            return this.accessToken;
-        }
-        try {
-            // Get a new token
-            const result = await this.msalClient.acquireTokenByClientCredential({
-                scopes: [`${this.config.organizationUrl}/.default`],
-            });
-            if (!result || !result.accessToken) {
-                throw new Error('Failed to acquire access token');
-            }
-            this.accessToken = result.accessToken;
-            // Set expiration time (subtract 5 minutes to refresh early)
-            if (result.expiresOn) {
-                this.tokenExpirationTime = result.expiresOn.getTime() - (5 * 60 * 1000);
-            }
-            return this.accessToken;
-        }
-        catch (error) {
-            console.error('Error acquiring access token:', error);
-            throw new Error('Authentication failed');
-        }
-    }
-    /**
-     * Make an authenticated request to the PowerPlatform API
-     * Extended to support all HTTP methods for write operations
-     */
-    async makeRequest(endpoint, method = 'GET', data, additionalHeaders) {
-        try {
-            const token = await this.getAccessToken();
-            const headers = {
-                'Authorization': `Bearer ${token}`,
-                'Accept': 'application/json',
-                'OData-MaxVersion': '4.0',
-                'OData-Version': '4.0',
-                ...additionalHeaders
-            };
-            // Add Content-Type for POST/PUT/PATCH requests
-            if (method !== 'GET' && method !== 'DELETE' && data) {
-                headers['Content-Type'] = 'application/json';
-            }
-            const response = await axios({
-                method,
-                url: `${this.config.organizationUrl}/${endpoint}`,
-                headers,
-                data
-            });
-            return response.data;
-        }
-        catch (error) {
-            const errorDetails = error.response?.data?.error || error.response?.data || error.message;
-            console.error('PowerPlatform API request failed:', {
-                endpoint,
-                method,
-                status: error.response?.status,
-                statusText: error.response?.statusText,
-                error: errorDetails
-            });
-            throw new Error(`PowerPlatform API request failed: ${error.message} - ${JSON.stringify(errorDetails)}`);
-        }
-    }
-    /**
-     * Get metadata about an entity
-     * @param entityName The logical name of the entity
-     */
+    client;
+    // Read-only services
+    metadata;
+    plugin;
+    flow;
+    workflow;
+    businessRule;
+    app;
+    validation;
+    // Customization services
+    entity;
+    attribute;
+    relationship;
+    optionSet;
+    form;
+    view;
+    webResource;
+    solution;
+    publishing;
+    dependency;
+    pluginDeployment;
+    appManagement;
+    workflowManagement;
+    constructor(config, authProvider) {
+        const auth = authProvider ||
+            createAuthProvider({
+                organizationUrl: config.organizationUrl,
+                clientId: config.clientId,
+                clientSecret: config.clientSecret,
+                tenantId: config.tenantId,
+            });
+        this.client = new PowerPlatformClient(config, auth);
+        // Initialize read-only services
+        this.metadata = new MetadataService(this.client);
+        this.plugin = new PluginService(this.client);
+        this.flow = new FlowService(this.client);
+        this.workflow = new WorkflowService(this.client);
+        this.businessRule = new BusinessRuleService(this.client);
+        this.app = new AppService(this.client);
+        this.validation = new ValidationService(this.client);
+        // Initialize customization services
+        this.entity = new EntityService(this.client);
+        this.attribute = new AttributeService(this.client);
+        this.relationship = new RelationshipService(this.client);
+        this.optionSet = new OptionSetService(this.client);
+        this.form = new FormService(this.client);
+        this.view = new ViewService(this.client);
+        this.webResource = new WebResourceService(this.client);
+        this.solution = new SolutionService(this.client);
+        this.publishing = new PublishingService(this.client);
+        this.dependency = new DependencyService(this.client);
+        // These services need cross-service dependencies
+        this.pluginDeployment = new PluginDeploymentService(this.client, (solutionUniqueName, componentId, componentType) => this.solution.addComponentToSolution(solutionUniqueName, componentId, componentType));
+        this.appManagement = new AppManagementService(this.client, async (appId) => this.app.getAppSitemap(appId));
+        this.workflowManagement = new WorkflowManagementService(this.client);
+    }
+    // =====================================================
+    // AUTH METHODS
+    // =====================================================
+    getAuthMode() {
+        return this.client.getAuthMode();
+    }
+    async getUserInfo() {
+        return this.client.getUserInfo();
+    }
+    async logout() {
+        return this.client.logout();
+    }
+    // =====================================================
+    // METADATA METHODS (Read-only)
+    // =====================================================
     async getEntityMetadata(entityName) {
-        const response = await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')`);
-        // Remove Privileges property if it exists
-        if (response && typeof response === 'object' && 'Privileges' in response) {
-            delete response.Privileges;
-        }
-        return response;
+        return this.metadata.getEntityMetadata(entityName);
     }
-    /**
-     * Get metadata about entity attributes/fields
-     * @param entityName The logical name of the entity
-     */
-    async getEntityAttributes(entityName) {
-        const selectProperties = [
-            'LogicalName',
-        ].join(',');
-        // Make the request to get attributes
-        const response = await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/Attributes?$select=${selectProperties}&$filter=AttributeType ne 'Virtual'`);
-        if (response && response.value) {
-            // First pass: Filter out attributes that end with 'yominame'
-            response.value = response.value.filter((attribute) => {
-                const logicalName = attribute.LogicalName || '';
-                return !logicalName.endsWith('yominame');
-            });
-            // Filter out attributes that end with 'name' if there is another attribute with the same name without the 'name' suffix
-            const baseNames = new Set();
-            const namesAttributes = new Map();
-            for (const attribute of response.value) {
-                const logicalName = attribute.LogicalName || '';
-                if (logicalName.endsWith('name') && logicalName.length > 4) {
-                    const baseName = logicalName.slice(0, -4); // Remove 'name' suffix
-                    namesAttributes.set(baseName, attribute);
-                }
-                else {
-                    // This is a potential base attribute
-                    baseNames.add(logicalName);
-                }
-            }
-            // Find attributes to remove that match the pattern
-            const attributesToRemove = new Set();
-            for (const [baseName, nameAttribute] of namesAttributes.entries()) {
-                if (baseNames.has(baseName)) {
-                    attributesToRemove.add(nameAttribute);
-                }
-            }
-            response.value = response.value.filter(attribute => !attributesToRemove.has(attribute));
-        }
-        return response;
+    async getEntityAttributes(entityName, options) {
+        return this.metadata.getEntityAttributes(entityName, options);
     }
-    /**
-     * Get metadata about a specific entity attribute/field
-     * @param entityName The logical name of the entity
-     * @param attributeName The logical name of the attribute
-     */
     async getEntityAttribute(entityName, attributeName) {
-        return this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/Attributes(LogicalName='${attributeName}')`);
-    }
-    /**
-     * Get one-to-many relationships for an entity
-     * @param entityName The logical name of the entity
-     */
-    async getEntityOneToManyRelationships(entityName) {
-        const selectProperties = [
-            'SchemaName',
-            'RelationshipType',
-            'ReferencedAttribute',
-            'ReferencedEntity',
-            'ReferencingAttribute',
-            'ReferencingEntity',
-            'ReferencedEntityNavigationPropertyName',
-            'ReferencingEntityNavigationPropertyName'
-        ].join(',');
-        // Only filter by ReferencingAttribute in the OData query since startswith isn't supported
-        const response = await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/OneToManyRelationships?$select=${selectProperties}&$filter=ReferencingAttribute ne 'regardingobjectid'`);
-        // Filter the response to exclude relationships with ReferencingEntity starting with 'msdyn_' or 'adx_'
-        if (response && response.value) {
-            response.value = response.value.filter((relationship) => {
-                const referencingEntity = relationship.ReferencingEntity || '';
-                return !(referencingEntity.startsWith('msdyn_') || referencingEntity.startsWith('adx_'));
-            });
-        }
-        return response;
-    }
-    /**
-     * Get many-to-many relationships for an entity
-     * @param entityName The logical name of the entity
-     */
-    async getEntityManyToManyRelationships(entityName) {
-        const selectProperties = [
-            'SchemaName',
-            'RelationshipType',
-            'Entity1LogicalName',
-            'Entity2LogicalName',
-            'Entity1IntersectAttribute',
-            'Entity2IntersectAttribute',
-            'Entity1NavigationPropertyName',
-            'Entity2NavigationPropertyName'
-        ].join(',');
-        return this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/ManyToManyRelationships?$select=${selectProperties}`);
+        return this.metadata.getEntityAttribute(entityName, attributeName);
     }
-    /**
-     * Get all relationships (one-to-many and many-to-many) for an entity
-     * @param entityName The logical name of the entity
-     */
     async getEntityRelationships(entityName) {
-        const [oneToMany, manyToMany] = await Promise.all([
-            this.getEntityOneToManyRelationships(entityName),
-            this.getEntityManyToManyRelationships(entityName)
-        ]);
-        return {
-            oneToMany,
-            manyToMany
-        };
+        return this.metadata.getEntityRelationships(entityName);
     }
-    /**
-     * Get a global option set definition by name
-     * @param optionSetName The name of the global option set
-     * @returns The global option set definition
-     */
     async getGlobalOptionSet(optionSetName) {
-        return this.makeRequest(`api/data/v9.2/GlobalOptionSetDefinitions(Name='${optionSetName}')`);
+        return this.metadata.getGlobalOptionSet(optionSetName);
     }
-    /**
-     * 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
-     */
-    async getRecord(entityNamePlural, recordId) {
-        return this.makeRequest(`api/data/v9.2/${entityNamePlural}(${recordId})`);
+    async getGlobalOptionSets(options) {
+        return this.metadata.getGlobalOptionSets(options);
     }
-    /**
-     * 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
-     */
-    async queryRecords(entityNamePlural, filter, maxRecords = 50) {
-        return this.makeRequest(`api/data/v9.2/${entityNamePlural}?$filter=${encodeURIComponent(filter)}&$top=${maxRecords}`);
+    // =====================================================
+    // PLUGIN METHODS (Read-only)
+    // =====================================================
+    async getPluginAssemblies(includeManaged, maxRecords) {
+        return this.plugin.getPluginAssemblies(includeManaged, maxRecords);
     }
-    /**
-     * 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
-     */
-    async createRecord(entityNamePlural, data) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Validate data is not empty
-            if (!data || Object.keys(data).length === 0) {
-                throw new Error('Record data cannot be empty');
-            }
-            // Make POST request to create record
-            const response = await this.makeRequest(`api/data/v9.2/${entityNamePlural}`, 'POST', data, {
-                'Prefer': 'return=representation', // Return the created record
-            });
-            // Audit logging
-            auditLogger.log({
-                operation: 'create-record',
-                operationType: 'CREATE',
-                componentType: 'Record',
-                componentName: entityNamePlural,
-                success: true,
-                executionTimeMs: timer(),
-            });
-            return response;
-        }
-        catch (error) {
-            // Audit failed operation
-            auditLogger.log({
-                operation: 'create-record',
-                operationType: 'CREATE',
-                componentType: 'Record',
-                componentName: entityNamePlural,
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
-    }
-    /**
-     * 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
-     */
-    async updateRecord(entityNamePlural, recordId, data) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Validate data is not empty
-            if (!data || Object.keys(data).length === 0) {
-                throw new Error('Update data cannot be empty');
-            }
-            // Validate recordId is a valid GUID
-            const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-            if (!guidRegex.test(recordId)) {
-                throw new Error(`Invalid record ID format: ${recordId}. Must be a valid GUID.`);
-            }
-            // Make PATCH request to update record
-            const response = await this.makeRequest(`api/data/v9.2/${entityNamePlural}(${recordId})`, 'PATCH', data, {
-                'Prefer': 'return=representation', // Return the updated record
-            });
-            // Audit logging
-            auditLogger.log({
-                operation: 'update-record',
-                operationType: 'UPDATE',
-                componentType: 'Record',
-                componentName: `${entityNamePlural}(${recordId})`,
-                success: true,
-                executionTimeMs: timer(),
-            });
-            return response;
-        }
-        catch (error) {
-            // Audit failed operation
-            auditLogger.log({
-                operation: 'update-record',
-                operationType: 'UPDATE',
-                componentType: 'Record',
-                componentName: `${entityNamePlural}(${recordId})`,
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    async getPluginAssemblyComplete(assemblyName, includeDisabled) {
+        return this.plugin.getPluginAssemblyComplete(assemblyName, includeDisabled);
     }
-    /**
-     * 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)
-     */
-    async deleteRecord(entityNamePlural, recordId) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Validate recordId is a valid GUID
-            const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-            if (!guidRegex.test(recordId)) {
-                throw new Error(`Invalid record ID format: ${recordId}. Must be a valid GUID.`);
-            }
-            // Make DELETE request
-            await this.makeRequest(`api/data/v9.2/${entityNamePlural}(${recordId})`, 'DELETE');
-            // Audit logging
-            auditLogger.log({
-                operation: 'delete-record',
-                operationType: 'DELETE',
-                componentType: 'Record',
-                componentName: `${entityNamePlural}(${recordId})`,
-                success: true,
-                executionTimeMs: timer(),
-            });
-        }
-        catch (error) {
-            // Audit failed operation
-            auditLogger.log({
-                operation: 'delete-record',
-                operationType: 'DELETE',
-                componentType: 'Record',
-                componentName: `${entityNamePlural}(${recordId})`,
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    async getEntityPluginPipeline(entityName, messageFilter, includeDisabled) {
+        return this.plugin.getEntityPluginPipeline(entityName, messageFilter, includeDisabled);
     }
-    /**
-     * 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
-     */
-    async getPluginAssemblies(includeManaged = false, maxRecords = 100) {
-        const managedFilter = includeManaged ? '' : '$filter=ismanaged eq false&';
-        const assemblies = await this.makeRequest(`api/data/v9.2/pluginassemblies?${managedFilter}$select=pluginassemblyid,name,version,culture,publickeytoken,isolationmode,sourcetype,major,minor,createdon,modifiedon,ismanaged,ishidden&$expand=modifiedby($select=fullname)&$orderby=name&$top=${maxRecords}`);
-        // Filter out hidden assemblies and format the results with more readable properties
-        // Note: ishidden is a ManagedProperty object with a Value property
-        const formattedAssemblies = assemblies.value
-            .filter((assembly) => {
-            const isHidden = assembly.ishidden?.Value !== undefined ? assembly.ishidden.Value : assembly.ishidden;
-            return !isHidden;
-        })
-            .map((assembly) => ({
-            pluginassemblyid: assembly.pluginassemblyid,
-            name: assembly.name,
-            version: assembly.version,
-            isolationMode: assembly.isolationmode === 1 ? 'None' : assembly.isolationmode === 2 ? 'Sandbox' : 'External',
-            isManaged: assembly.ismanaged,
-            modifiedOn: assembly.modifiedon,
-            modifiedBy: assembly.modifiedby?.fullname,
-            major: assembly.major,
-            minor: assembly.minor
-        }));
-        return {
-            totalCount: formattedAssemblies.length,
-            assemblies: formattedAssemblies
-        };
-    }
-    /**
-     * 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
-     */
-    async getPluginAssemblyComplete(assemblyName, includeDisabled = false) {
-        // Get the plugin assembly (excluding content_binary which is large and not useful for review)
-        const assemblies = await this.makeRequest(`api/data/v9.2/pluginassemblies?$filter=name eq '${assemblyName}'&$select=pluginassemblyid,name,version,culture,publickeytoken,isolationmode,sourcetype,major,minor,createdon,modifiedon,ismanaged,ishidden,description&$expand=modifiedby($select=fullname)`);
-        if (!assemblies.value || assemblies.value.length === 0) {
-            throw new Error(`Plugin assembly '${assemblyName}' not found`);
-        }
-        const assembly = assemblies.value[0];
-        const assemblyId = assembly.pluginassemblyid;
-        // Get plugin types for this assembly
-        const pluginTypes = await this.makeRequest(`api/data/v9.2/plugintypes?$filter=_pluginassemblyid_value eq ${assemblyId}&$select=plugintypeid,typename,friendlyname,name,assemblyname,description,workflowactivitygroupname`);
-        // Get all steps for each plugin type
-        const pluginTypeIds = pluginTypes.value.map((pt) => pt.plugintypeid);
-        let allSteps = [];
-        if (pluginTypeIds.length > 0) {
-            const statusFilter = includeDisabled ? '' : ' and statuscode eq 1';
-            // Build filter for all plugin type IDs
-            const typeFilter = pluginTypeIds.map((id) => `_plugintypeid_value eq ${id}`).join(' or ');
-            const steps = await this.makeRequest(`api/data/v9.2/sdkmessageprocessingsteps?$filter=(${typeFilter})${statusFilter}&$select=sdkmessageprocessingstepid,name,stage,mode,rank,statuscode,asyncautodelete,filteringattributes,supporteddeployment,configuration,description,invocationsource,_plugintypeid_value,_sdkmessagefilterid_value,_impersonatinguserid_value,_eventhandler_value&$expand=sdkmessageid($select=name),plugintypeid($select=typename),impersonatinguserid($select=fullname),modifiedby($select=fullname),sdkmessagefilterid($select=primaryobjecttypecode)&$orderby=stage,rank`);
-            allSteps = steps.value;
-        }
-        // Get all images for these steps
-        const stepIds = allSteps.map((s) => s.sdkmessageprocessingstepid);
-        let allImages = [];
-        if (stepIds.length > 0) {
-            // Build filter for all step IDs
-            const imageFilter = stepIds.map((id) => `_sdkmessageprocessingstepid_value eq ${id}`).join(' or ');
-            const images = await this.makeRequest(`api/data/v9.2/sdkmessageprocessingstepimages?$filter=${imageFilter}&$select=sdkmessageprocessingstepimageid,name,imagetype,messagepropertyname,entityalias,attributes,_sdkmessageprocessingstepid_value`);
-            allImages = images.value;
-        }
-        // Attach images to their respective steps
-        const stepsWithImages = allSteps.map((step) => ({
-            ...step,
-            images: allImages.filter((img) => img._sdkmessageprocessingstepid_value === step.sdkmessageprocessingstepid)
-        }));
-        // Validation checks
-        const validation = {
-            hasDisabledSteps: allSteps.some((s) => s.statuscode !== 1),
-            hasAsyncSteps: allSteps.some((s) => s.mode === 1),
-            hasSyncSteps: allSteps.some((s) => s.mode === 0),
-            stepsWithoutFilteringAttributes: stepsWithImages
-                .filter((s) => (s.sdkmessageid?.name === 'Update' || s.sdkmessageid?.name === 'Delete') && !s.filteringattributes)
-                .map((s) => s.name),
-            stepsWithoutImages: stepsWithImages
-                .filter((s) => s.images.length === 0 && (s.sdkmessageid?.name === 'Update' || s.sdkmessageid?.name === 'Delete'))
-                .map((s) => s.name),
-            potentialIssues: []
-        };
-        // Add potential issues
-        if (validation.stepsWithoutFilteringAttributes.length > 0) {
-            validation.potentialIssues.push(`${validation.stepsWithoutFilteringAttributes.length} Update/Delete steps without filtering attributes (performance concern)`);
-        }
-        if (validation.stepsWithoutImages.length > 0) {
-            validation.potentialIssues.push(`${validation.stepsWithoutImages.length} Update/Delete steps without images (may need entity data)`);
-        }
-        return {
-            assembly,
-            pluginTypes: pluginTypes.value,
-            steps: stepsWithImages,
-            validation
-        };
-    }
-    /**
-     * 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
-     */
-    async getEntityPluginPipeline(entityName, messageFilter, includeDisabled = false) {
-        const statusFilter = includeDisabled ? '' : ' and statuscode eq 1';
-        const msgFilter = messageFilter ? ` and sdkmessageid/name eq '${messageFilter}'` : '';
-        // Get all steps for this entity
-        const steps = await this.makeRequest(`api/data/v9.2/sdkmessageprocessingsteps?$filter=sdkmessagefilterid/primaryobjecttypecode eq '${entityName}'${statusFilter}${msgFilter}&$select=sdkmessageprocessingstepid,name,stage,mode,rank,statuscode,asyncautodelete,filteringattributes,supporteddeployment,configuration,description,_plugintypeid_value,_sdkmessagefilterid_value,_impersonatinguserid_value&$expand=sdkmessageid($select=name),plugintypeid($select=typename),impersonatinguserid($select=fullname),sdkmessagefilterid($select=primaryobjecttypecode)&$orderby=stage,rank`);
-        // Get assembly information for each plugin type (filter out nulls)
-        const pluginTypeIds = [...new Set(steps.value.map((s) => s._plugintypeid_value).filter((id) => id != null))];
-        const assemblyMap = new Map();
-        for (const typeId of pluginTypeIds) {
-            const pluginType = await this.makeRequest(`api/data/v9.2/plugintypes(${typeId})?$expand=pluginassemblyid($select=name,version)`);
-            assemblyMap.set(typeId, pluginType.pluginassemblyid);
-        }
-        // Get images for all steps
-        const stepIds = steps.value.map((s) => s.sdkmessageprocessingstepid);
-        let allImages = [];
-        if (stepIds.length > 0) {
-            const imageFilter = stepIds.map((id) => `_sdkmessageprocessingstepid_value eq ${id}`).join(' or ');
-            const images = await this.makeRequest(`api/data/v9.2/sdkmessageprocessingstepimages?$filter=${imageFilter}&$select=sdkmessageprocessingstepimageid,name,imagetype,messagepropertyname,entityalias,attributes,_sdkmessageprocessingstepid_value`);
-            allImages = images.value;
-        }
-        // Format steps with all information
-        const formattedSteps = steps.value.map((step) => {
-            const assembly = assemblyMap.get(step._plugintypeid_value);
-            const images = allImages.filter((img) => img._sdkmessageprocessingstepid_value === step.sdkmessageprocessingstepid);
-            return {
-                sdkmessageprocessingstepid: step.sdkmessageprocessingstepid,
-                name: step.name,
-                stage: step.stage,
-                stageName: step.stage === 10 ? 'PreValidation' : step.stage === 20 ? 'PreOperation' : 'PostOperation',
-                mode: step.mode,
-                modeName: step.mode === 0 ? 'Synchronous' : 'Asynchronous',
-                rank: step.rank,
-                message: step.sdkmessageid?.name,
-                pluginType: step.plugintypeid?.typename,
-                assemblyName: assembly?.name,
-                assemblyVersion: assembly?.version,
-                filteringAttributes: step.filteringattributes ? step.filteringattributes.split(',') : [],
-                statuscode: step.statuscode,
-                enabled: step.statuscode === 1,
-                deployment: step.supporteddeployment === 0 ? 'Server' : step.supporteddeployment === 1 ? 'Offline' : 'Both',
-                impersonatingUser: step.impersonatinguserid?.fullname,
-                hasPreImage: images.some((img) => img.imagetype === 0 || img.imagetype === 2),
-                hasPostImage: images.some((img) => img.imagetype === 1 || img.imagetype === 2),
-                images: images
-            };
-        });
-        // Organize by message
-        const messageGroups = new Map();
-        formattedSteps.forEach((step) => {
-            if (!messageGroups.has(step.message)) {
-                messageGroups.set(step.message, {
-                    messageName: step.message,
-                    stages: {
-                        preValidation: [],
-                        preOperation: [],
-                        postOperation: []
-                    }
-                });
-            }
-            const msg = messageGroups.get(step.message);
-            if (step.stage === 10)
-                msg.stages.preValidation.push(step);
-            else if (step.stage === 20)
-                msg.stages.preOperation.push(step);
-            else if (step.stage === 40)
-                msg.stages.postOperation.push(step);
-        });
-        return {
-            entity: entityName,
-            messages: Array.from(messageGroups.values()),
-            steps: formattedSteps,
-            executionOrder: formattedSteps.map((s) => s.name)
-        };
-    }
-    /**
-     * Get plugin trace logs with filtering
-     * @param options Filtering options for trace logs
-     * @returns Filtered trace logs with parsed exception details
-     */
     async getPluginTraceLogs(options) {
-        const { entityName, messageName, correlationId, pluginStepId, exceptionOnly = false, hoursBack = 24, maxRecords = 50 } = options;
-        // Build filter
-        const filters = [];
-        // Date filter
-        const dateThreshold = new Date();
-        dateThreshold.setHours(dateThreshold.getHours() - hoursBack);
-        filters.push(`createdon gt ${dateThreshold.toISOString()}`);
-        if (entityName)
-            filters.push(`primaryentity eq '${entityName}'`);
-        if (messageName)
-            filters.push(`messagename eq '${messageName}'`);
-        if (correlationId)
-            filters.push(`correlationid eq '${correlationId}'`);
-        if (pluginStepId)
-            filters.push(`_sdkmessageprocessingstepid_value eq ${pluginStepId}`);
-        if (exceptionOnly)
-            filters.push(`exceptiondetails ne null`);
-        const filterString = filters.join(' and ');
-        const logs = await this.makeRequest(`api/data/v9.2/plugintracelogs?$filter=${filterString}&$orderby=createdon desc&$top=${maxRecords}`);
-        // Parse logs for better readability
-        const parsedLogs = logs.value.map((log) => ({
-            ...log,
-            modeName: log.mode === 0 ? 'Synchronous' : 'Asynchronous',
-            operationTypeName: this.getOperationTypeName(log.operationtype),
-            parsed: {
-                hasException: !!log.exceptiondetails,
-                exceptionType: log.exceptiondetails ? this.extractExceptionType(log.exceptiondetails) : null,
-                exceptionMessage: log.exceptiondetails ? this.extractExceptionMessage(log.exceptiondetails) : null,
-                stackTrace: log.exceptiondetails
-            }
-        }));
-        return {
-            totalCount: parsedLogs.length,
-            logs: parsedLogs
-        };
-    }
-    // Helper methods for trace log parsing
-    getOperationTypeName(operationType) {
-        const types = {
-            0: 'None',
-            1: 'Create',
-            2: 'Update',
-            3: 'Delete',
-            4: 'Retrieve',
-            5: 'RetrieveMultiple',
-            6: 'Associate',
-            7: 'Disassociate'
-        };
-        return types[operationType] || 'Unknown';
-    }
-    extractExceptionType(exceptionDetails) {
-        const match = exceptionDetails.match(/^([^:]+):/);
-        return match ? match[1].trim() : null;
-    }
-    extractExceptionMessage(exceptionDetails) {
-        const lines = exceptionDetails.split('\n');
-        if (lines.length > 0) {
-            const firstLine = lines[0];
-            const colonIndex = firstLine.indexOf(':');
-            if (colonIndex > 0) {
-                return firstLine.substring(colonIndex + 1).trim();
-            }
-        }
-        return null;
-    }
-    /**
-     * Get all Power Automate flows (cloud flows) in the environment
-     * @param activeOnly Only return activated flows (default: false)
-     * @param maxRecords Maximum number of flows to return (default: 100)
-     * @returns List of Power Automate flows with basic information
-     */
-    async getFlows(activeOnly = false, maxRecords = 100) {
-        // Category 5 = Modern Flow (Power Automate cloud flows)
-        // StateCode: 0=Draft, 1=Activated, 2=Suspended
-        // Type: 1=Definition, 2=Activation
-        const stateFilter = activeOnly ? ' and statecode eq 1' : '';
-        const flows = await this.makeRequest(`api/data/v9.2/workflows?$filter=category eq 5${stateFilter}&$select=workflowid,name,statecode,statuscode,description,createdon,modifiedon,type,ismanaged,iscrmuiworkflow,primaryentity,clientdata&$expand=modifiedby($select=fullname)&$orderby=modifiedon desc&$top=${maxRecords}`);
-        // Format the results for better readability
-        const formattedFlows = flows.value.map((flow) => ({
-            workflowid: flow.workflowid,
-            name: flow.name,
-            description: flow.description,
-            state: flow.statecode === 0 ? 'Draft' : flow.statecode === 1 ? 'Activated' : 'Suspended',
-            statecode: flow.statecode,
-            statuscode: flow.statuscode,
-            type: flow.type === 1 ? 'Definition' : flow.type === 2 ? 'Activation' : 'Template',
-            primaryEntity: flow.primaryentity,
-            isManaged: flow.ismanaged,
-            ownerId: flow._ownerid_value,
-            modifiedOn: flow.modifiedon,
-            modifiedBy: flow.modifiedby?.fullname,
-            createdOn: flow.createdon,
-            hasDefinition: !!flow.clientdata
-        }));
-        return {
-            totalCount: formattedFlows.length,
-            flows: formattedFlows
-        };
-    }
-    /**
-     * 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
-     */
-    async getFlowDefinition(flowId) {
-        const flow = await this.makeRequest(`api/data/v9.2/workflows(${flowId})?$select=workflowid,name,statecode,statuscode,description,createdon,modifiedon,type,category,ismanaged,iscrmuiworkflow,primaryentity,clientdata,xaml&$expand=modifiedby($select=fullname),createdby($select=fullname)`);
-        // Parse the clientdata (flow definition) if it exists
-        let flowDefinition = null;
-        if (flow.clientdata) {
-            try {
-                flowDefinition = JSON.parse(flow.clientdata);
-            }
-            catch (error) {
-                console.error('Failed to parse flow definition JSON:', error);
-                flowDefinition = { parseError: 'Failed to parse flow definition', raw: flow.clientdata };
-            }
-        }
-        return {
-            workflowid: flow.workflowid,
-            name: flow.name,
-            description: flow.description,
-            state: flow.statecode === 0 ? 'Draft' : flow.statecode === 1 ? 'Activated' : 'Suspended',
-            statecode: flow.statecode,
-            statuscode: flow.statuscode,
-            type: flow.type === 1 ? 'Definition' : flow.type === 2 ? 'Activation' : 'Template',
-            category: flow.category,
-            primaryEntity: flow.primaryentity,
-            isManaged: flow.ismanaged,
-            ownerId: flow._ownerid_value,
-            createdOn: flow.createdon,
-            createdBy: flow.createdby?.fullname,
-            modifiedOn: flow.modifiedon,
-            modifiedBy: flow.modifiedby?.fullname,
-            flowDefinition: flowDefinition
-        };
-    }
-    /**
-     * 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
-     */
-    async getFlowRuns(flowId, maxRecords = 100) {
-        // Flow runs are stored in the flowruns entity (not flowsession)
-        // Status: "Succeeded", "Failed", "Faulted", "TimedOut", "Cancelled", "Running", etc.
-        const flowRuns = await this.makeRequest(`api/data/v9.2/flowruns?$filter=_workflow_value eq ${flowId}&$select=flowrunid,name,status,starttime,endtime,duration,errormessage,errorcode,triggertype&$orderby=starttime desc&$top=${maxRecords}`);
-        // Format the results for better readability
-        const formattedRuns = flowRuns.value.map((run) => {
-            // Parse error message if it's JSON
-            let parsedError = run.errormessage;
-            if (run.errormessage) {
-                try {
-                    parsedError = JSON.parse(run.errormessage);
-                }
-                catch (e) {
-                    // Keep as string if not valid JSON
-                }
-            }
-            return {
-                flowrunid: run.flowrunid,
-                name: run.name,
-                status: run.status,
-                startedOn: run.starttime,
-                completedOn: run.endtime,
-                duration: run.duration,
-                errorMessage: parsedError || null,
-                errorCode: run.errorcode || null,
-                triggerType: run.triggertype || null
-            };
-        });
-        return {
-            flowId: flowId,
-            totalCount: formattedRuns.length,
-            runs: formattedRuns
-        };
-    }
-    /**
-     * 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
-     */
-    async getWorkflows(activeOnly = false, maxRecords = 100) {
-        // Category 0 = Classic Workflow
-        // StateCode: 0=Draft, 1=Activated, 2=Suspended
-        // Type: 1=Definition, 2=Activation
-        const stateFilter = activeOnly ? ' and statecode eq 1' : '';
-        const workflows = await this.makeRequest(`api/data/v9.2/workflows?$filter=category eq 0${stateFilter}&$select=workflowid,name,statecode,statuscode,description,createdon,modifiedon,type,ismanaged,iscrmuiworkflow,primaryentity,mode,subprocess,ondemand,triggeroncreate,triggerondelete,syncworkflowlogonfailure&$expand=ownerid($select=fullname),modifiedby($select=fullname)&$orderby=modifiedon desc&$top=${maxRecords}`);
-        // Format the results for better readability
-        const formattedWorkflows = workflows.value.map((workflow) => ({
-            workflowid: workflow.workflowid,
-            name: workflow.name,
-            description: workflow.description,
-            state: workflow.statecode === 0 ? 'Draft' : workflow.statecode === 1 ? 'Activated' : 'Suspended',
-            statecode: workflow.statecode,
-            statuscode: workflow.statuscode,
-            type: workflow.type === 1 ? 'Definition' : workflow.type === 2 ? 'Activation' : 'Template',
-            mode: workflow.mode === 0 ? 'Background' : 'Real-time',
-            primaryEntity: workflow.primaryentity,
-            isManaged: workflow.ismanaged,
-            isOnDemand: workflow.ondemand,
-            triggerOnCreate: workflow.triggeroncreate,
-            triggerOnDelete: workflow.triggerondelete,
-            isSubprocess: workflow.subprocess,
-            owner: workflow.ownerid?.fullname,
-            modifiedOn: workflow.modifiedon,
-            modifiedBy: workflow.modifiedby?.fullname,
-            createdOn: workflow.createdon
-        }));
-        return {
-            totalCount: formattedWorkflows.length,
-            workflows: formattedWorkflows
-        };
-    }
-    /**
-     * Get a specific classic workflow with its complete XAML definition
-     * @param workflowId The GUID of the workflow (workflowid)
-     * @returns Complete workflow information including the XAML definition
-     */
-    async getWorkflowDefinition(workflowId) {
-        const workflow = await this.makeRequest(`api/data/v9.2/workflows(${workflowId})?$select=workflowid,name,statecode,statuscode,description,createdon,modifiedon,type,category,ismanaged,iscrmuiworkflow,primaryentity,mode,subprocess,ondemand,triggeroncreate,triggerondelete,triggeronupdateattributelist,syncworkflowlogonfailure,xaml&$expand=ownerid($select=fullname),modifiedby($select=fullname),createdby($select=fullname)`);
-        return {
-            workflowid: workflow.workflowid,
-            name: workflow.name,
-            description: workflow.description,
-            state: workflow.statecode === 0 ? 'Draft' : workflow.statecode === 1 ? 'Activated' : 'Suspended',
-            statecode: workflow.statecode,
-            statuscode: workflow.statuscode,
-            type: workflow.type === 1 ? 'Definition' : workflow.type === 2 ? 'Activation' : 'Template',
-            category: workflow.category,
-            mode: workflow.mode === 0 ? 'Background' : 'Real-time',
-            primaryEntity: workflow.primaryentity,
-            isManaged: workflow.ismanaged,
-            isOnDemand: workflow.ondemand,
-            triggerOnCreate: workflow.triggeroncreate,
-            triggerOnDelete: workflow.triggerondelete,
-            triggerOnUpdateAttributes: workflow.triggeronupdateattributelist ? workflow.triggeronupdateattributelist.split(',') : [],
-            isSubprocess: workflow.subprocess,
-            syncWorkflowLogOnFailure: workflow.syncworkflowlogonfailure,
-            owner: workflow.ownerid?.fullname,
-            createdOn: workflow.createdon,
-            createdBy: workflow.createdby?.fullname,
-            modifiedOn: workflow.modifiedon,
-            modifiedBy: workflow.modifiedby?.fullname,
-            xaml: workflow.xaml
-        };
-    }
-    /**
-     * Update a workflow's description field
-     * @param workflowId GUID of the workflow
-     * @param description New description content
-     * @returns Previous and new description
-     */
-    async updateWorkflowDescription(workflowId, description) {
-        // Client-side length validation (Power Platform limit: 1024 characters)
-        const MAX_DESCRIPTION_LENGTH = 1024;
-        if (description.length > MAX_DESCRIPTION_LENGTH) {
-            const overage = description.length - MAX_DESCRIPTION_LENGTH;
-            throw new Error(`Description too long (${description.length}/${MAX_DESCRIPTION_LENGTH} chars). ` +
-                `Please shorten by ${overage} character${overage === 1 ? '' : 's'}.`);
-        }
-        // First, get current description for audit trail
-        const currentWorkflow = await this.makeRequest(`api/data/v9.2/workflows(${workflowId})?$select=description`);
-        const previousDescription = currentWorkflow.description || '';
-        // Update description
-        await this.makeRequest(`api/data/v9.2/workflows(${workflowId})`, 'PATCH', { description });
-        return {
-            success: true,
-            previousDescription,
-            newDescription: description
-        };
+        return this.plugin.getPluginTraceLogs(options);
     }
-    /**
-     * Deactivate a workflow (set to Draft state)
-     * @param workflowId GUID of the workflow
-     * @returns Previous and new state information
-     */
-    async deactivateWorkflow(workflowId) {
-        // First, get current state for audit trail
-        const currentWorkflow = await this.makeRequest(`api/data/v9.2/workflows(${workflowId})?$select=workflowid,name,statecode,statuscode`);
-        const previousState = currentWorkflow.statecode === 0 ? 'Draft' :
-            currentWorkflow.statecode === 1 ? 'Activated' : 'Suspended';
-        // If already in Draft state, return success without making API call
-        if (currentWorkflow.statecode === 0) {
-            auditLogger.log({
-                operation: 'deactivate-workflow',
-                operationType: 'UPDATE',
-                componentType: 'workflow',
-                componentName: currentWorkflow.name,
-                componentId: workflowId,
-                parameters: { previousState, result: 'already-draft' },
-                success: true,
-            });
-            return {
-                success: true,
-                workflowId,
-                workflowName: currentWorkflow.name,
-                previousState,
-                newState: 'Draft',
-            };
-        }
-        // Deactivate workflow using SetState action
-        // State: 0=Draft, Status: 1=Draft
-        try {
-            await this.makeRequest(`api/data/v9.2/workflows(${workflowId})/Microsoft.Dynamics.CRM.SetState`, 'POST', {
-                State: 0,
-                Status: 1
-            });
-            auditLogger.log({
-                operation: 'deactivate-workflow',
-                operationType: 'UPDATE',
-                componentType: 'workflow',
-                componentName: currentWorkflow.name,
-                componentId: workflowId,
-                parameters: { previousState, newState: 'Draft' },
-                success: true,
-            });
-            return {
-                success: true,
-                workflowId,
-                workflowName: currentWorkflow.name,
-                previousState,
-                newState: 'Draft',
-            };
-        }
-        catch (error) {
-            // Handle expected error codes
-            if (error.response?.data?.error?.code === '0x80045003') {
-                // Workflow is already in target state - treat as success
-                auditLogger.log({
-                    operation: 'deactivate-workflow',
-                    operationType: 'UPDATE',
-                    componentType: 'workflow',
-                    componentName: currentWorkflow.name,
-                    componentId: workflowId,
-                    parameters: { previousState, result: 'already-draft' },
-                    success: true,
-                });
-                return {
-                    success: true,
-                    workflowId,
-                    workflowName: currentWorkflow.name,
-                    previousState,
-                    newState: 'Draft',
-                };
-            }
-            // Re-throw unexpected errors
-            throw error;
-        }
+    // =====================================================
+    // FLOW METHODS (Read-only)
+    // =====================================================
+    async getFlows(options) {
+        return this.flow.getFlows(options);
     }
-    /**
-     * Activate a workflow (set to Activated state)
-     * @param workflowId GUID of the workflow
-     * @returns Previous and new state information
-     */
-    async activateWorkflow(workflowId) {
-        // First, get current state for audit trail
-        const currentWorkflow = await this.makeRequest(`api/data/v9.2/workflows(${workflowId})?$select=workflowid,name,statecode,statuscode`);
-        const previousState = currentWorkflow.statecode === 0 ? 'Draft' :
-            currentWorkflow.statecode === 1 ? 'Activated' : 'Suspended';
-        // If already in Activated state, return success without making API call
-        if (currentWorkflow.statecode === 1) {
-            auditLogger.log({
-                operation: 'activate-workflow',
-                operationType: 'UPDATE',
-                componentType: 'workflow',
-                componentName: currentWorkflow.name,
-                componentId: workflowId,
-                parameters: { previousState, result: 'already-activated' },
-                success: true,
-            });
-            return {
-                success: true,
-                workflowId,
-                workflowName: currentWorkflow.name,
-                previousState,
-                newState: 'Activated',
-            };
-        }
-        // Activate workflow using SetState action
-        // State: 1=Activated, Status: 2=Activated
-        try {
-            await this.makeRequest(`api/data/v9.2/workflows(${workflowId})/Microsoft.Dynamics.CRM.SetState`, 'POST', {
-                State: 1,
-                Status: 2
-            });
-            auditLogger.log({
-                operation: 'activate-workflow',
-                operationType: 'UPDATE',
-                componentType: 'workflow',
-                componentName: currentWorkflow.name,
-                componentId: workflowId,
-                parameters: { previousState, newState: 'Activated' },
-                success: true,
-            });
-            return {
-                success: true,
-                workflowId,
-                workflowName: currentWorkflow.name,
-                previousState,
-                newState: 'Activated',
-            };
-        }
-        catch (error) {
-            // Handle expected error codes
-            if (error.response?.data?.error?.code === '0x80045003') {
-                // Workflow is already in target state - treat as success
-                auditLogger.log({
-                    operation: 'activate-workflow',
-                    operationType: 'UPDATE',
-                    componentType: 'workflow',
-                    componentName: currentWorkflow.name,
-                    componentId: workflowId,
-                    parameters: { previousState, result: 'already-activated' },
-                    success: true,
-                });
-                return {
-                    success: true,
-                    workflowId,
-                    workflowName: currentWorkflow.name,
-                    previousState,
-                    newState: 'Activated',
-                };
-            }
-            // Re-throw unexpected errors
-            throw error;
-        }
+    async getFlowDefinition(flowId, summary) {
+        return this.flow.getFlowDefinition(flowId, summary);
     }
-    /**
-     * Document a workflow safely by deactivating, updating description, and reactivating
-     * Atomic operation with rollback on failure
-     * @param workflowId GUID of the workflow
-     * @param type Type of automation ('flow' or 'workflow'), auto-detected if not provided
-     * @returns Documentation result with state management summary
-     */
-    async documentWorkflowSafe(workflowId, type) {
-        // Step 1: Get initial workflow state
-        const currentWorkflow = await this.makeRequest(`api/data/v9.2/workflows(${workflowId})?$select=workflowid,name,statecode,statuscode`);
-        const initialState = currentWorkflow.statecode === 0 ? 'Draft' :
-            currentWorkflow.statecode === 1 ? 'Activated' : 'Suspended';
-        const wasInitiallyActive = currentWorkflow.statecode === 1;
-        auditLogger.log({
-            operation: 'document-workflow-safe-start',
-            operationType: 'UPDATE',
-            componentType: 'workflow',
-            componentName: currentWorkflow.name,
-            componentId: workflowId,
-            parameters: { initialState },
-            success: true,
-        });
-        let wasDeactivated = false;
-        let wasReactivated = false;
-        try {
-            // Step 2: Deactivate workflow if needed
-            if (wasInitiallyActive) {
-                const deactivateResult = await this.deactivateWorkflow(workflowId);
-                wasDeactivated = deactivateResult.success;
-                if (!wasDeactivated) {
-                    throw new Error('Failed to deactivate workflow');
-                }
-            }
-            // Step 3: Document the automation
-            let documentResult;
-            try {
-                documentResult = await this.documentAutomation(workflowId, type);
-            }
-            catch (documentError) {
-                // Documentation failed - attempt to restore initial state
-                if (wasDeactivated && wasInitiallyActive) {
-                    auditLogger.log({
-                        operation: 'document-workflow-safe-rollback',
-                        operationType: 'UPDATE',
-                        componentType: 'workflow',
-                        componentName: currentWorkflow.name,
-                        componentId: workflowId,
-                        parameters: { reason: 'documentation-failed' },
-                        success: false,
-                        error: documentError.message,
-                    });
-                    try {
-                        await this.activateWorkflow(workflowId);
-                    }
-                    catch (rollbackError) {
-                        // Log rollback failure but throw original error
-                        auditLogger.log({
-                            operation: 'document-workflow-safe-rollback-failed',
-                            operationType: 'UPDATE',
-                            componentType: 'workflow',
-                            componentName: currentWorkflow.name,
-                            componentId: workflowId,
-                            success: false,
-                            error: rollbackError.message,
-                        });
-                    }
-                }
-                throw new Error(`Documentation failed: ${documentError.message}`);
-            }
-            // Step 4: Reactivate workflow if it was initially active
-            if (wasInitiallyActive) {
-                try {
-                    const activateResult = await this.activateWorkflow(workflowId);
-                    wasReactivated = activateResult.success;
-                    if (!wasReactivated) {
-                        // Critical: Documentation succeeded but reactivation failed
-                        auditLogger.log({
-                            operation: 'document-workflow-safe-reactivation-failed',
-                            operationType: 'UPDATE',
-                            componentType: 'workflow',
-                            componentName: currentWorkflow.name,
-                            componentId: workflowId,
-                            parameters: { warning: 'Workflow documented but remains deactivated - manual reactivation required' },
-                            success: false,
-                        });
-                        return {
-                            success: true, // Documentation succeeded even if reactivation failed
-                            workflowId,
-                            workflowName: currentWorkflow.name,
-                            analysis: documentResult.analysis,
-                            descriptionUpdated: documentResult.descriptionUpdated,
-                            previousDescription: documentResult.previousDescription,
-                            newDescription: documentResult.newDescription,
-                            stateManagement: {
-                                initialState,
-                                wasDeactivated,
-                                wasReactivated: false,
-                                finalState: 'Draft (⚠️ Manual reactivation required)',
-                            },
-                        };
-                    }
-                }
-                catch (reactivationError) {
-                    // Log reactivation failure
-                    auditLogger.log({
-                        operation: 'document-workflow-safe-reactivation-error',
-                        operationType: 'UPDATE',
-                        componentType: 'workflow',
-                        componentName: currentWorkflow.name,
-                        componentId: workflowId,
-                        success: false,
-                        error: reactivationError.message,
-                    });
-                    return {
-                        success: true, // Documentation succeeded even if reactivation failed
-                        workflowId,
-                        workflowName: currentWorkflow.name,
-                        analysis: documentResult.analysis,
-                        descriptionUpdated: documentResult.descriptionUpdated,
-                        previousDescription: documentResult.previousDescription,
-                        newDescription: documentResult.newDescription,
-                        stateManagement: {
-                            initialState,
-                            wasDeactivated,
-                            wasReactivated: false,
-                            finalState: 'Draft (⚠️ Manual reactivation required)',
-                        },
-                    };
-                }
-            }
-            // Success - all steps completed
-            const finalState = wasInitiallyActive ? 'Activated' : 'Draft';
-            auditLogger.log({
-                operation: 'document-workflow-safe-complete',
-                operationType: 'UPDATE',
-                componentType: 'workflow',
-                componentName: currentWorkflow.name,
-                componentId: workflowId,
-                parameters: { initialState, finalState, wasDeactivated, wasReactivated },
-                success: true,
-            });
-            return {
-                success: true,
-                workflowId,
-                workflowName: currentWorkflow.name,
-                analysis: documentResult.analysis,
-                descriptionUpdated: documentResult.descriptionUpdated,
-                previousDescription: documentResult.previousDescription,
-                newDescription: documentResult.newDescription,
-                stateManagement: {
-                    initialState,
-                    wasDeactivated,
-                    wasReactivated,
-                    finalState,
-                },
-            };
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'document-workflow-safe-error',
-                operationType: 'UPDATE',
-                componentType: 'workflow',
-                componentName: currentWorkflow.name,
-                componentId: workflowId,
-                success: false,
-                error: error.message,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Generate YAML metadata block for automation documentation
-     */
-    generateAutomationYaml(analysis) {
-        const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
-        return `[AUTO-DOCS:v1]
-tables_modified: ${analysis.tablesModified.join(', ') || 'none'}
-trigger: ${analysis.trigger}
-trigger_fields: ${analysis.triggerFields.join(', ') || 'none'}
-custom_apis_called: ${analysis.customApisCalled && analysis.customApisCalled.length > 0 ? analysis.customApisCalled.join(', ') : 'none'}
-action_count: ${analysis.actionCount}
-analyzed: ${today}
----`;
-    }
-    /**
-     * Merge YAML metadata with existing description, preserving manual notes
-     */
-    mergeDescriptionWithYaml(yamlBlock, existingDescription) {
-        // Case 1: Empty description
-        if (!existingDescription || existingDescription.trim() === '') {
-            return `${yamlBlock}\n[Manual notes below this line are preserved on re-analysis]`;
-        }
-        // Case 2: Has [AUTO-DOCS: tag - extract and preserve content after ---
-        const autoDocsMatch = existingDescription.match(/\[AUTO-DOCS:v\d+\]([\s\S]*?)^---$/m);
-        if (autoDocsMatch) {
-            const separatorIndex = existingDescription.indexOf('---', autoDocsMatch.index);
-            const manualNotes = existingDescription.substring(separatorIndex + 3).trim();
-            if (manualNotes) {
-                return `${yamlBlock}\n${manualNotes}`;
-            }
-            else {
-                return `${yamlBlock}\n[Manual notes below this line are preserved on re-analysis]`;
-            }
-        }
-        // Case 3: Has content but no [AUTO-DOCS: tag - treat entire content as manual notes
-        return `${yamlBlock}\n${existingDescription.trim()}`;
+    async getFlowRuns(flowId, maxRecords) {
+        return this.flow.getFlowRuns(flowId, maxRecords);
     }
-    /**
-     * Analyze a flow or workflow and document it with YAML metadata
-     * @param automationId GUID of the flow or workflow
-     * @param type Type of automation ('flow' or 'workflow'), auto-detected if not provided
-     * @returns Analysis and description update result
-     */
-    async documentAutomation(automationId, type) {
-        // Fetch automation (flow or workflow)
-        const accessToken = await this.getAccessToken();
-        const response = await fetch(`${this.config.organizationUrl}/api/data/v9.2/workflows(${automationId})?$select=category,clientdata,description`, {
-            headers: {
-                'Authorization': `Bearer ${accessToken}`,
-                'Accept': 'application/json',
-                'OData-MaxVersion': '4.0',
-                'OData-Version': '4.0'
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch automation: ${response.status} ${response.statusText}`);
-        }
-        const automation = await response.json();
-        const previousDescription = automation.description || '';
-        // Detect type if not provided (category 5 = flow, 0 = workflow)
-        const detectedType = type || (automation.category === 5 ? 'flow' : 'workflow');
-        let analysis;
-        if (detectedType === 'flow') {
-            // Parse flow definition from clientdata
-            if (!automation.clientdata) {
-                throw new Error('Flow has no clientdata (definition)');
-            }
-            const flowDefinition = JSON.parse(automation.clientdata);
-            // Use enhanced parser from base package
-            const readOnlyService = new PowerPlatformReadOnlyService({
-                organizationUrl: this.config.organizationUrl,
-                clientId: this.config.clientId,
-                clientSecret: this.config.clientSecret,
-                tenantId: this.config.tenantId
-            });
-            // Call public method from base package
-            const summary = readOnlyService.parseFlowSummary(flowDefinition);
-            // Convert action objects to action names for display
-            const actionNames = Array.isArray(summary.actions)
-                ? summary.actions.map((a) => a.name || a.type || 'unknown').slice(0, 10)
-                : [];
-            analysis = {
-                tablesModified: summary.tablesModified,
-                trigger: summary.triggerInfo,
-                triggerFields: summary.triggerFields,
-                actions: actionNames,
-                actionCount: Array.isArray(summary.actions) ? summary.actions.length : 0,
-                customApisCalled: summary.customApisCalled || []
-            };
-        }
-        else {
-            // Fetch workflow XAML
-            const xamlResponse = await fetch(`${this.config.organizationUrl}/api/data/v9.2/workflows(${automationId})?$select=xaml`, {
-                headers: {
-                    'Authorization': `Bearer ${accessToken}`,
-                    'Accept': 'application/json',
-                    'OData-MaxVersion': '4.0',
-                    'OData-Version': '4.0'
-                }
-            });
-            if (!xamlResponse.ok) {
-                throw new Error(`Failed to fetch workflow XAML: ${xamlResponse.status}`);
-            }
-            const xamlData = await xamlResponse.json();
-            if (!xamlData.xaml) {
-                throw new Error('Workflow has no XAML definition');
-            }
-            // Use enhanced parser from base package
-            const readOnlyService = new PowerPlatformReadOnlyService({
-                organizationUrl: this.config.organizationUrl,
-                clientId: this.config.clientId,
-                clientSecret: this.config.clientSecret,
-                tenantId: this.config.tenantId
-            });
-            const summary = readOnlyService.parseWorkflowXamlSummary(xamlData.xaml);
-            // Get action types from XAML
-            const actions = [];
-            if (summary.createEntityCount > 0)
-                actions.push('create_record');
-            if (summary.updateEntityCount > 0)
-                actions.push('update_record');
-            if (summary.assignEntityCount > 0)
-                actions.push('assign_record');
-            if (summary.setStateCount > 0)
-                actions.push('set_state');
-            analysis = {
-                tablesModified: summary.tablesModified,
-                trigger: summary.triggerInfo,
-                triggerFields: summary.triggerFields,
-                actions,
-                actionCount: actions.length,
-                customApisCalled: [] // Classic workflows don't support Custom APIs directly
-            };
-        }
-        // Generate YAML and merge with existing description
-        const yamlBlock = this.generateAutomationYaml(analysis);
-        const newDescription = this.mergeDescriptionWithYaml(yamlBlock, previousDescription);
-        // Update description
-        const updateResult = await this.updateWorkflowDescription(automationId, newDescription);
-        return {
-            analysis,
-            descriptionUpdated: updateResult.success,
-            previousDescription: updateResult.previousDescription,
-            newDescription: updateResult.newDescription
-        };
+    // =====================================================
+    // WORKFLOW METHODS (Read-only)
+    // =====================================================
+    async getWorkflows(activeOnly, maxRecords) {
+        return this.workflow.getWorkflows(activeOnly, maxRecords);
     }
-    /**
-     * Update a Power Automate flow's description field
-     * @param flowId GUID of the flow (workflowid in workflows entity)
-     * @param description New description content
-     * @returns Previous and new description
-     */
-    async updateFlowDescription(flowId, description) {
-        // Flows and workflows share the same entity and update mechanism
-        // The only difference is category (5 = flow, 0 = workflow)
-        return this.updateWorkflowDescription(flowId, description);
+    async getWorkflowDefinition(workflowId, summary) {
+        return this.workflow.getWorkflowDefinition(workflowId, summary);
     }
-    /**
-     * 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
-     */
-    async getBusinessRules(activeOnly = false, maxRecords = 100) {
-        // Category 2 = Business Rule
-        // StateCode: 0=Draft, 1=Activated, 2=Suspended
-        // Type: 1=Definition
-        const stateFilter = activeOnly ? ' and statecode eq 1' : '';
-        const businessRules = await this.makeRequest(`api/data/v9.2/workflows?$filter=category eq 2${stateFilter}&$select=workflowid,name,statecode,statuscode,description,createdon,modifiedon,type,ismanaged,primaryentity&$expand=ownerid($select=fullname),modifiedby($select=fullname)&$orderby=modifiedon desc&$top=${maxRecords}`);
-        // Format the results for better readability
-        const formattedBusinessRules = businessRules.value.map((rule) => ({
-            workflowid: rule.workflowid,
-            name: rule.name,
-            description: rule.description,
-            state: rule.statecode === 0 ? 'Draft' : rule.statecode === 1 ? 'Activated' : 'Suspended',
-            statecode: rule.statecode,
-            statuscode: rule.statuscode,
-            type: rule.type === 1 ? 'Definition' : rule.type === 2 ? 'Activation' : 'Template',
-            primaryEntity: rule.primaryentity,
-            isManaged: rule.ismanaged,
-            owner: rule.ownerid?.fullname,
-            modifiedOn: rule.modifiedon,
-            modifiedBy: rule.modifiedby?.fullname,
-            createdOn: rule.createdon
-        }));
-        return {
-            totalCount: formattedBusinessRules.length,
-            businessRules: formattedBusinessRules
-        };
+    // =====================================================
+    // BUSINESS RULE METHODS (Read-only)
+    // =====================================================
+    async getBusinessRules(activeOnly, maxRecords) {
+        return this.businessRule.getBusinessRules(activeOnly, maxRecords);
     }
-    /**
-     * 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
-     */
     async getBusinessRule(workflowId) {
-        const businessRule = await this.makeRequest(`api/data/v9.2/workflows(${workflowId})?$select=workflowid,name,statecode,statuscode,description,createdon,modifiedon,type,category,ismanaged,primaryentity,xaml&$expand=ownerid($select=fullname),modifiedby($select=fullname),createdby($select=fullname)`);
-        // Verify it's actually a business rule
-        if (businessRule.category !== 2) {
-            throw new Error(`Workflow ${workflowId} is not a business rule (category: ${businessRule.category})`);
-        }
-        return {
-            workflowid: businessRule.workflowid,
-            name: businessRule.name,
-            description: businessRule.description,
-            state: businessRule.statecode === 0 ? 'Draft' : businessRule.statecode === 1 ? 'Activated' : 'Suspended',
-            statecode: businessRule.statecode,
-            statuscode: businessRule.statuscode,
-            type: businessRule.type === 1 ? 'Definition' : businessRule.type === 2 ? 'Activation' : 'Template',
-            category: businessRule.category,
-            primaryEntity: businessRule.primaryentity,
-            isManaged: businessRule.ismanaged,
-            owner: businessRule.ownerid?.fullname,
-            createdOn: businessRule.createdon,
-            createdBy: businessRule.createdby?.fullname,
-            modifiedOn: businessRule.modifiedon,
-            modifiedBy: businessRule.modifiedby?.fullname,
-            xaml: businessRule.xaml
-        };
+        return this.businessRule.getBusinessRule(workflowId);
     }
-    // ==================== MODEL-DRIVEN APP OPERATIONS ====================
-    /**
-     * 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
-     */
-    async getApps(activeOnly = false, maxRecords = 100, includeUnpublished = true, solutionUniqueName) {
-        // Build filter conditions
-        const filters = [];
-        // StateCode: 0=Active, 1=Inactive
-        if (activeOnly) {
-            filters.push('statecode eq 0');
-        }
-        // Published status: publishedon null = unpublished
-        if (!includeUnpublished) {
-            filters.push('publishedon ne null');
-        }
-        const filterString = filters.length > 0 ? `&$filter=${filters.join(' and ')}` : '';
-        const apps = await this.makeRequest(`api/data/v9.2/appmodules?$select=appmoduleid,name,uniquename,description,webresourceid,clienttype,formfactor,navigationtype,url,isfeatured,isdefault,publishedon,statecode,statuscode,_publisherid_value,createdon,modifiedon&$orderby=modifiedon desc&$top=${maxRecords}${filterString}`);
-        // If solution filter specified, filter results by solution
-        let filteredApps = apps.value;
-        if (solutionUniqueName) {
-            // Query solution components to find apps in the specified solution
-            const solution = await this.makeRequest(`api/data/v9.2/solutions?$filter=uniquename eq '${solutionUniqueName}'&$select=solutionid`);
-            if (solution.value.length > 0) {
-                const solutionId = solution.value[0].solutionid;
-                // Query solution components for app modules
-                const solutionComponents = await this.makeRequest(`api/data/v9.2/solutioncomponents?$filter=_solutionid_value eq ${solutionId} and componenttype eq 80&$select=objectid`);
-                const appIdsInSolution = new Set(solutionComponents.value.map((c) => c.objectid.toLowerCase()));
-                filteredApps = apps.value.filter((app) => appIdsInSolution.has(app.appmoduleid.toLowerCase()));
-            }
-        }
-        // Format the results for better readability
-        const formattedApps = filteredApps.map((app) => ({
-            appmoduleid: app.appmoduleid,
-            name: app.name,
-            uniquename: app.uniquename,
-            description: app.description,
-            webresourceid: app.webresourceid,
-            clienttype: app.clienttype,
-            formfactor: app.formfactor,
-            navigationtype: app.navigationtype,
-            url: app.url,
-            isfeatured: app.isfeatured,
-            isdefault: app.isdefault,
-            state: app.statecode === 0 ? 'Active' : 'Inactive',
-            statecode: app.statecode,
-            statuscode: app.statuscode,
-            publishedon: app.publishedon,
-            published: app.publishedon ? true : false,
-            publisherid: app._publisherid_value || null,
-            createdon: app.createdon,
-            modifiedon: app.modifiedon
-        }));
-        return {
-            totalCount: formattedApps.length,
-            apps: formattedApps,
-            filters: {
-                activeOnly,
-                includeUnpublished,
-                solutionUniqueName: solutionUniqueName || 'all'
-            }
-        };
+    // =====================================================
+    // APP METHODS (Read-only)
+    // =====================================================
+    async getApps(activeOnly, maxRecords, includeUnpublished, solutionUniqueName) {
+        return this.app.getApps(activeOnly, maxRecords, includeUnpublished, solutionUniqueName);
     }
-    /**
-     * Get a specific model-driven app by ID
-     * @param appId The GUID of the app (appmoduleid)
-     * @returns Complete app information including publisher details
-     */
     async getApp(appId) {
-        const app = await this.makeRequest(`api/data/v9.2/appmodules(${appId})?$select=appmoduleid,name,uniquename,description,webresourceid,clienttype,formfactor,navigationtype,url,isfeatured,isdefault,publishedon,statecode,statuscode,configxml,createdon,modifiedon,_publisherid_value,_createdby_value,_modifiedby_value`);
-        return {
-            appmoduleid: app.appmoduleid,
-            name: app.name,
-            uniquename: app.uniquename,
-            description: app.description,
-            webresourceid: app.webresourceid,
-            clienttype: app.clienttype,
-            formfactor: app.formfactor,
-            navigationtype: app.navigationtype === 0 ? 'Single Session' : 'Multi Session',
-            url: app.url,
-            isfeatured: app.isfeatured,
-            isdefault: app.isdefault,
-            state: app.statecode === 0 ? 'Active' : 'Inactive',
-            statecode: app.statecode,
-            statuscode: app.statuscode,
-            publishedon: app.publishedon,
-            createdon: app.createdon,
-            modifiedon: app.modifiedon,
-            createdBy: app._createdby_value || null,
-            modifiedBy: app._modifiedby_value || null,
-            publisherid: app._publisherid_value || null
-        };
+        return this.app.getApp(appId);
     }
-    /**
-     * 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
-     */
     async getAppComponents(appId) {
-        const components = await this.makeRequest(`api/data/v9.2/appmodulecomponents?$filter=_appmoduleidunique_value eq ${appId}&$select=appmodulecomponentid,objectid,componenttype,rootappmodulecomponentid,createdon,modifiedon&$orderby=componenttype asc`);
-        // Map component type numbers to friendly names
-        const componentTypeMap = {
-            1: 'Entity',
-            24: 'Form',
-            26: 'View',
-            29: 'Business Process Flow',
-            48: 'Ribbon Command',
-            59: 'Chart/Dashboard',
-            60: 'System Form',
-            62: 'SiteMap'
-        };
-        const formattedComponents = components.value.map((component) => ({
-            appmodulecomponentid: component.appmodulecomponentid,
-            objectid: component.objectid,
-            componenttype: component.componenttype,
-            componenttypeName: componentTypeMap[component.componenttype] || `Unknown (${component.componenttype})`,
-            rootappmodulecomponentid: component.rootappmodulecomponentid,
-            createdon: component.createdon,
-            modifiedon: component.modifiedon
-        }));
-        // Group by component type for easier reading
-        const groupedByType = {};
-        formattedComponents.forEach((comp) => {
-            const typeName = comp.componenttypeName;
-            if (!groupedByType[typeName]) {
-                groupedByType[typeName] = [];
-            }
-            groupedByType[typeName].push(comp);
-        });
-        return {
-            totalCount: formattedComponents.length,
-            components: formattedComponents,
-            groupedByType
-        };
+        return this.app.getAppComponents(appId);
     }
-    /**
-     * Get the sitemap for a specific app
-     * @param appId The GUID of the app (appmoduleid)
-     * @returns Sitemap information including XML
-     */
     async getAppSitemap(appId) {
-        // First get the app components to find the sitemap
-        const components = await this.makeRequest(`api/data/v9.2/appmodulecomponents?$filter=_appmoduleidunique_value eq ${appId} and componenttype eq 62&$select=objectid`);
-        if (components.value.length === 0) {
-            return {
-                hasSitemap: false,
-                message: 'No sitemap found for this app'
-            };
-        }
-        // Get the sitemap details
-        const sitemapId = components.value[0].objectid;
-        const sitemap = await this.makeRequest(`api/data/v9.2/sitemaps(${sitemapId})?$select=sitemapid,sitemapname,sitemapnameunique,sitemapxml,isappaware,enablecollapsiblegroups,showhome,showpinned,showrecents,ismanaged,createdon,modifiedon`);
-        return {
-            hasSitemap: true,
-            sitemapid: sitemap.sitemapid,
-            sitemapname: sitemap.sitemapname,
-            sitemapnameunique: sitemap.sitemapnameunique,
-            sitemapxml: sitemap.sitemapxml,
-            isappaware: sitemap.isappaware,
-            enablecollapsiblegroups: sitemap.enablecollapsiblegroups,
-            showhome: sitemap.showhome,
-            showpinned: sitemap.showpinned,
-            showrecents: sitemap.showrecents,
-            ismanaged: sitemap.ismanaged,
-            createdon: sitemap.createdon,
-            modifiedon: sitemap.modifiedon
-        };
-    }
-    /**
-     * 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
-     */
-    async createApp(appDefinition, solutionUniqueName) {
-        const startTime = Date.now();
-        try {
-            // Validate uniquename format (English chars/numbers only, no spaces)
-            const uniquename = appDefinition.uniquename;
-            if (!/^[a-zA-Z0-9_]+$/.test(uniquename)) {
-                throw new Error('App uniquename must contain only English letters, numbers, and underscores (no spaces)');
-            }
-            // Set defaults
-            const appRequest = {
-                name: appDefinition.name,
-                uniquename: appDefinition.uniquename,
-                description: appDefinition.description || '',
-                webresourceid: appDefinition.webresourceid || '953b9fac-1e5e-e611-80d6-00155ded156f', // Default icon
-                welcomepageid: '00000000-0000-0000-0000-000000000000', // Required: empty GUID for no welcome page
-                clienttype: appDefinition.clienttype || 4, // UCI
-                formfactor: appDefinition.formfactor || 1, // Unknown/All
-                navigationtype: appDefinition.navigationtype !== undefined ? appDefinition.navigationtype : 0, // Single session
-                isfeatured: appDefinition.isfeatured || false,
-                isdefault: appDefinition.isdefault || false,
-                url: appDefinition.url || ''
-            };
-            // Headers with solution context and return representation
-            const headers = {
-                'Prefer': 'return=representation'
-            };
-            if (solutionUniqueName) {
-                headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-            }
-            // Execute with rate limiting
-            const response = await rateLimiter.execute(async () => {
-                return await this.makeRequest('api/data/v9.2/appmodules', 'POST', appRequest, headers);
-            });
-            // Extract app ID from response (now returned due to Prefer header)
-            const appId = response.appmoduleid;
-            if (!appId) {
-                throw new Error('App creation response missing appmoduleid. Full response: ' + JSON.stringify(response));
-            }
-            // Verify the app is queryable (retry with delay if needed)
-            let appVerified = false;
-            let retryCount = 0;
-            const maxRetries = 3;
-            const retryDelayMs = 2000;
-            while (!appVerified && retryCount < maxRetries) {
-                try {
-                    await this.makeRequest(`api/data/v9.2/appmodules(${appId})?$select=appmoduleid,name,uniquename`);
-                    appVerified = true;
-                }
-                catch (error) {
-                    retryCount++;
-                    if (retryCount < maxRetries) {
-                        await new Promise(resolve => setTimeout(resolve, retryDelayMs));
-                    }
-                }
-            }
-            // Audit log success
-            auditLogger.log({
-                operation: 'createApp',
-                operationType: 'CREATE',
-                componentType: 'AppModule',
-                componentName: appDefinition.name,
-                componentId: appId,
-                success: true,
-                executionTimeMs: Date.now() - startTime
-            });
-            return {
-                appId,
-                name: appDefinition.name,
-                uniquename: appDefinition.uniquename,
-                verified: appVerified,
-                message: appVerified
-                    ? 'App created successfully and verified. Remember to add entities, validate, and publish.'
-                    : `App created successfully (ID: ${appId}) but verification timed out. The app may need time to propagate in the system. Use get-app with the returned appId to check status.`
-            };
-        }
-        catch (error) {
-            // Audit log failure
-            auditLogger.log({
-                operation: 'createApp',
-                operationType: 'CREATE',
-                componentType: 'AppModule',
-                componentName: appDefinition.name,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw new Error(`Failed to create app: ${error.message}`);
-        }
+        return this.app.getAppSitemap(appId);
     }
-    /**
-     * 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
-     */
-    async createSimpleSitemap(config, solutionUniqueName) {
-        const startTime = Date.now();
-        try {
-            // Generate sitemap XML from simplified configuration
-            let xml = '<SiteMap>';
-            config.areas.forEach((area) => {
-                xml += `<Area Id="${area.id}"`;
-                if (area.icon) {
-                    xml += ` Icon="${area.icon}"`;
-                }
-                if (area.showGroups !== undefined) {
-                    xml += ` ShowGroups="${area.showGroups}"`;
-                }
-                xml += '>';
-                xml += `<Titles><Title LCID="1033" Title="${this.escapeXml(area.title)}" /></Titles>`;
-                if (area.description) {
-                    xml += `<Descriptions><Description LCID="1033" Description="${this.escapeXml(area.description)}" /></Descriptions>`;
-                }
-                area.groups.forEach((group) => {
-                    xml += `<Group Id="${group.id}"`;
-                    if (group.isProfile !== undefined) {
-                        xml += ` IsProfile="${group.isProfile}"`;
-                    }
-                    xml += '>';
-                    xml += `<Titles><Title LCID="1033" Title="${this.escapeXml(group.title)}" /></Titles>`;
-                    if (group.description) {
-                        xml += `<Descriptions><Description LCID="1033" Description="${this.escapeXml(group.description)}" /></Descriptions>`;
-                    }
-                    group.subareas.forEach((subarea) => {
-                        xml += `<SubArea Id="${subarea.id}"`;
-                        if (subarea.entity) {
-                            xml += ` Entity="${subarea.entity}"`;
-                        }
-                        if (subarea.url) {
-                            xml += ` Url="${subarea.url}"`;
-                        }
-                        if (subarea.icon) {
-                            xml += ` Icon="${subarea.icon}"`;
-                        }
-                        if (subarea.availableOffline !== undefined) {
-                            xml += ` AvailableOffline="${subarea.availableOffline}"`;
-                        }
-                        if (subarea.passParams !== undefined) {
-                            xml += ` PassParams="${subarea.passParams}"`;
-                        }
-                        xml += '>';
-                        xml += `<Titles><Title LCID="1033" Title="${this.escapeXml(subarea.title)}" /></Titles>`;
-                        if (subarea.description) {
-                            xml += `<Descriptions><Description LCID="1033" Description="${this.escapeXml(subarea.description)}" /></Descriptions>`;
-                        }
-                        xml += '</SubArea>';
-                    });
-                    xml += '</Group>';
-                });
-                xml += '</Area>';
-            });
-            xml += '</SiteMap>';
-            // Create sitemap entity
-            const sitemapRequest = {
-                sitemapname: config.name,
-                sitemapxml: xml,
-                isappaware: true,
-                enablecollapsiblegroups: config.enableCollapsibleGroups !== undefined ? config.enableCollapsibleGroups : false,
-                showhome: config.showHome !== undefined ? config.showHome : true,
-                showpinned: config.showPinned !== undefined ? config.showPinned : true,
-                showrecents: config.showRecents !== undefined ? config.showRecents : true
-            };
-            // Headers with solution context
-            const headers = {};
-            if (solutionUniqueName) {
-                headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-            }
-            // Execute with rate limiting
-            const response = await rateLimiter.execute(async () => {
-                return await this.makeRequest('api/data/v9.2/sitemaps', 'POST', sitemapRequest, headers);
-            });
-            // Extract sitemap ID from response
-            const sitemapId = response.sitemapid;
-            // Audit log success
-            auditLogger.log({
-                operation: 'createSimpleSitemap',
-                operationType: 'CREATE',
-                componentType: 'SiteMap',
-                componentName: config.name,
-                componentId: sitemapId,
-                success: true,
-                executionTimeMs: Date.now() - startTime
-            });
-            return {
-                sitemapId,
-                sitemapName: config.name,
-                sitemapXml: xml,
-                message: 'Sitemap created successfully. Add it to your app using add-entities-to-app or add specific components.'
-            };
-        }
-        catch (error) {
-            // Audit log failure
-            auditLogger.log({
-                operation: 'createSimpleSitemap',
-                operationType: 'CREATE',
-                componentType: 'SiteMap',
-                componentName: config.name,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw new Error(`Failed to create sitemap: ${error.message}`);
-        }
-    }
-    /**
-     * 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
-     */
-    async addEntitiesToApp(appId, entityNames) {
-        const startTime = Date.now();
-        try {
-            // Get app details
-            const app = await this.makeRequest(`api/data/v9.2/appmodules(${appId})?$select=appmoduleid,name,uniquename`);
-            // Validate entities exist and get their display names
-            const entityPromises = entityNames.map(name => this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${name}')?$select=LogicalName,DisplayName,MetadataId`));
-            const entities = await Promise.all(entityPromises);
-            // Try to get the app's sitemap via components first
-            let sitemapInfo = await this.getAppSitemap(appId);
-            // If not found via components, try to find by matching name
-            if (!sitemapInfo.hasSitemap) {
-                const sitemapQuery = await this.makeRequest(`api/data/v9.2/sitemaps?$filter=sitemapnameunique eq '${app.uniquename}'&$select=sitemapid,sitemapname,sitemapnameunique,sitemapxml`);
-                if (sitemapQuery.value.length > 0) {
-                    const sitemap = sitemapQuery.value[0];
-                    sitemapInfo = {
-                        hasSitemap: true,
-                        sitemapid: sitemap.sitemapid,
-                        sitemapname: sitemap.sitemapname,
-                        sitemapnameunique: sitemap.sitemapnameunique,
-                        sitemapxml: sitemap.sitemapxml
-                    };
-                }
-                else {
-                    throw new Error(`App '${app.name}' does not have a sitemap. Cannot add entities without a sitemap.`);
-                }
-            }
-            // Parse sitemap XML
-            let sitemapXml = sitemapInfo.sitemapxml;
-            // Find or create a "Tables" area and group
-            // Check if <Area> with Id="Area_Tables" exists
-            const areaRegex = /<Area[^>]+Id="Area_Tables"[^>]*>/;
-            const hasTablesArea = areaRegex.test(sitemapXml);
-            if (!hasTablesArea) {
-                // Add a new Area for tables before the closing </SiteMap>
-                const newArea = `
-  <Area Id="Area_Tables" Title="Tables" ShowGroups="true">
-    <Group Id="Group_Tables" Title="Custom Tables">
-    </Group>
-  </Area>`;
-                sitemapXml = sitemapXml.replace('</SiteMap>', newArea + '\n</SiteMap>');
-            }
-            // Add SubArea elements for each entity within Group_Tables
-            for (const entity of entities) {
-                const displayName = entity.DisplayName?.UserLocalizedLabel?.Label || entity.LogicalName;
-                const subAreaId = `SubArea_${entity.LogicalName}`;
-                // Check if SubArea already exists
-                const subAreaRegex = new RegExp(`<SubArea[^>]+Id="${subAreaId}"[^>]*>`);
-                if (subAreaRegex.test(sitemapXml)) {
-                    continue; // Skip if already exists
-                }
-                // Add SubArea within Group_Tables
-                const newSubArea = `
-      <SubArea Id="${subAreaId}" Entity="${entity.LogicalName}" Title="${displayName}" />`;
-                // Find the Group_Tables closing tag and add before it
-                sitemapXml = sitemapXml.replace(/<\/Group>/, newSubArea + '\n    </Group>');
-            }
-            // Update the sitemap
-            await rateLimiter.execute(async () => {
-                return await this.makeRequest(`api/data/v9.2/sitemaps(${sitemapInfo.sitemapid})`, 'PATCH', {
-                    sitemapxml: sitemapXml
-                });
-            });
-            // CRITICAL: Also add entity components to app for Advanced Find/Search
-            // Use deep insert via appmodule_appmodulecomponent collection navigation property
-            for (const entity of entities) {
-                try {
-                    await rateLimiter.execute(async () => {
-                        return await this.makeRequest(`api/data/v9.2/appmodules(${appId})/appmodule_appmodulecomponent`, 'POST', {
-                            componenttype: 1, // Entity
-                            objectid: entity.MetadataId
-                        });
-                    });
-                }
-                catch (componentError) {
-                    // If deep insert fails, try to continue with other entities
-                    auditLogger.log({
-                        operation: 'addEntitiesToApp',
-                        operationType: 'CREATE',
-                        componentType: 'AppModuleComponent',
-                        componentName: entity.LogicalName,
-                        success: false,
-                        error: `Failed to add ${entity.LogicalName} as app component: ${componentError.message}`,
-                        executionTimeMs: Date.now() - startTime
-                    });
-                }
-            }
-            // Audit log success
-            auditLogger.log({
-                operation: 'addEntitiesToApp',
-                operationType: 'UPDATE',
-                componentType: 'AppModule',
-                componentId: appId,
-                success: true,
-                executionTimeMs: Date.now() - startTime
-            });
-            return {
-                appId,
-                sitemapId: sitemapInfo.sitemapid,
-                entitiesAdded: entityNames,
-                message: `Successfully added ${entityNames.length} entities to app sitemap. Remember to publish the app.`
-            };
-        }
-        catch (error) {
-            // Audit log failure
-            auditLogger.log({
-                operation: 'addEntitiesToApp',
-                operationType: 'UPDATE',
-                componentType: 'AppModule',
-                componentId: appId,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw new Error(`Failed to add entities to app: ${error.message}`);
-        }
-    }
-    /**
-     * Validate an app before publishing
-     * @param appId The GUID of the app
-     * @returns Validation result with any issues found
-     */
-    async validateApp(appId) {
-        try {
-            const response = await this.makeRequest(`api/data/v9.2/ValidateApp(AppModuleId=${appId})`);
-            const validationResponse = response.AppValidationResponse;
-            const isValid = validationResponse.ValidationSuccess;
-            const issues = validationResponse.ValidationIssueList || [];
-            return {
-                appId,
-                isValid,
-                issueCount: issues.length,
-                issues: issues.map((issue) => ({
-                    errorType: issue.ErrorType,
-                    message: issue.Message,
-                    componentId: issue.ComponentId,
-                    componentType: issue.ComponentType
-                })),
-                message: isValid
-                    ? 'App validation passed. Ready to publish.'
-                    : `App validation found ${issues.length} issue(s). Fix them before publishing.`
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to validate app: ${error.message}`);
-        }
-    }
-    /**
-     * Publish an app to make it available to users
-     * @param appId The GUID of the app
-     * @returns Result of the publish operation
-     */
-    async publishApp(appId) {
-        const startTime = Date.now();
-        try {
-            // First validate the app
-            const validation = await this.validateApp(appId);
-            if (!validation.isValid) {
-                throw new Error(`Cannot publish app with validation errors: ${JSON.stringify(validation.issues)}`);
-            }
-            // Publish using PublishXml with app parameter
-            const parameterXml = `<importexportxml><appmodules><appmodule>${appId}</appmodule></appmodules></importexportxml>`;
-            await rateLimiter.execute(async () => {
-                return await this.publishXml(parameterXml);
-            });
-            // Audit log success
-            auditLogger.log({
-                operation: 'publishApp',
-                operationType: 'PUBLISH',
-                componentType: 'AppModule',
-                componentId: appId,
-                success: true,
-                executionTimeMs: Date.now() - startTime
-            });
-            return {
-                appId,
-                message: 'App published successfully. It is now available to users with appropriate security roles.'
-            };
-        }
-        catch (error) {
-            // Audit log failure
-            auditLogger.log({
-                operation: 'publishApp',
-                operationType: 'PUBLISH',
-                componentType: 'AppModule',
-                componentId: appId,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw new Error(`Failed to publish app: ${error.message}`);
-        }
-    }
-    /**
-     * Helper to escape XML special characters
-     */
-    escapeXml(unsafe) {
-        return unsafe.replace(/[<>&'"]/g, (c) => {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-                case '\'': return '&apos;';
-                case '"': return '&quot;';
-                default: return c;
-            }
-        });
-    }
-    // ==================== CUSTOMIZATION WRITE OPERATIONS ====================
-    /**
-     * 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
-     */
+    // =====================================================
+    // ENTITY CUSTOMIZATION METHODS
+    // =====================================================
     async createEntity(entityDefinition, solutionUniqueName) {
-        const startTime = Date.now();
-        try {
-            // Validate entity name against best practices
-            const schemaName = entityDefinition.SchemaName || entityDefinition.LogicalName;
-            const isRefData = schemaName?.toLowerCase().includes('ref_') || false;
-            const nameValidation = bestPracticesValidator.validateEntityName(schemaName, isRefData);
-            if (!nameValidation.isValid) {
-                const error = `Entity name validation failed: ${nameValidation.issues.join(', ')}`;
-                auditLogger.log({
-                    operation: 'createEntity',
-                    operationType: 'CREATE',
-                    componentType: 'Entity',
-                    componentName: schemaName,
-                    success: false,
-                    error,
-                    executionTimeMs: Date.now() - startTime
-                });
-                throw new Error(error);
-            }
-            // Log warnings if any
-            if (nameValidation.warnings.length > 0) {
-                console.error(`[WARNING] Entity name warnings: ${nameValidation.warnings.join(', ')}`);
-            }
-            // Validate ownership type
-            const ownershipType = entityDefinition.OwnershipType;
-            if (ownershipType) {
-                const ownershipValidation = bestPracticesValidator.validateOwnershipType(ownershipType);
-                if (!ownershipValidation.isValid) {
-                    console.error(`[WARNING] ${ownershipValidation.issues.join(', ')}`);
-                }
-            }
-            // Check for required columns
-            const requiredColumnsValidation = bestPracticesValidator.validateRequiredColumns([], isRefData);
-            if (requiredColumnsValidation.missingColumns && requiredColumnsValidation.missingColumns.length > 0) {
-                console.error('[WARNING] Entity will need required columns added after creation:', requiredColumnsValidation.missingColumns.map(c => c.schemaName).join(', '));
-            }
-            const headers = {};
-            if (solutionUniqueName) {
-                headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-            }
-            // Execute with rate limiting
-            const response = await rateLimiter.execute(async () => {
-                return await this.makeRequest('api/data/v9.2/EntityDefinitions', 'POST', entityDefinition, headers);
-            });
-            // Log success
-            auditLogger.log({
-                operation: 'createEntity',
-                operationType: 'CREATE',
-                componentType: 'Entity',
-                componentName: schemaName,
-                success: true,
-                executionTimeMs: Date.now() - startTime
-            });
-            return response;
-        }
-        catch (error) {
-            // Log failure
-            auditLogger.log({
-                operation: 'createEntity',
-                operationType: 'CREATE',
-                componentType: 'Entity',
-                componentName: entityDefinition.SchemaName || entityDefinition.LogicalName,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw error;
-        }
+        return this.entity.createEntity(entityDefinition, solutionUniqueName);
     }
-    /**
-     * Update an existing entity
-     * @param metadataId The MetadataId of the entity
-     * @param updates The properties to update
-     * @param solutionUniqueName Optional solution context
-     */
     async updateEntity(metadataId, updates, solutionUniqueName) {
-        const headers = {
-            'MSCRM.MergeLabels': 'true'
-        };
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        await this.makeRequest(`api/data/v9.2/EntityDefinitions(${metadataId})`, 'PUT', updates, headers);
+        return this.entity.updateEntity(metadataId, updates, solutionUniqueName);
     }
-    /**
-     * Delete a custom entity
-     * @param metadataId The MetadataId of the entity to delete
-     */
     async deleteEntity(metadataId) {
-        await this.makeRequest(`api/data/v9.2/EntityDefinitions(${metadataId})`, 'DELETE');
+        return this.entity.deleteEntity(metadataId);
     }
-    /**
-     * 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
-     */
     async updateEntityIcon(entityLogicalName, iconFileName, solutionUniqueName) {
-        const startTime = Date.now();
-        try {
-            // Step 1: Get entity metadata to retrieve schema name and metadata ID
-            const entityMetadata = await this.getEntityMetadata(entityLogicalName);
-            const entitySchemaName = entityMetadata.SchemaName;
-            const metadataId = entityMetadata.MetadataId;
-            if (!metadataId) {
-                throw new Error(`Could not find MetadataId for entity '${entityLogicalName}'`);
-            }
-            // Note: No need to clear existing IconVectorName - PowerPlatform will override it
-            // when we set the new icon. This avoids potential API errors from setting null values.
-            // Step 2: Fetch the icon SVG from Fluent UI GitHub
-            const svgContent = await iconManager.fetchIcon(iconFileName);
-            // Step 3: Validate the SVG
-            const validation = iconManager.validateIconSvg(svgContent);
-            if (!validation.valid) {
-                throw new Error(`Invalid SVG: ${validation.error}`);
-            }
-            // Step 4: Convert SVG to base64
-            const base64Content = Buffer.from(svgContent).toString('base64');
-            // Step 5: Generate web resource name
-            const webResourceName = iconManager.generateWebResourceName(entitySchemaName, iconFileName.replace('.svg', ''));
-            // Step 6: Check if web resource already exists (use exact name match)
-            const existingResourcesResponse = await this.makeRequest(`api/data/v9.2/webresourceset?$filter=name eq '${webResourceName}'&$select=webresourceid,name`);
-            let webResourceId;
-            if (existingResourcesResponse.value && existingResourcesResponse.value.length > 0) {
-                // Web resource exists, update it
-                const existing = existingResourcesResponse.value[0];
-                webResourceId = existing.webresourceid;
-                const webResourceUpdates = {
-                    displayname: `Icon for ${entityMetadata.DisplayName?.UserLocalizedLabel?.Label || entityLogicalName}`,
-                    content: base64Content,
-                    description: `Fluent UI icon (${iconFileName}) for ${entityLogicalName} entity`
-                };
-                await this.updateWebResource(webResourceId, webResourceUpdates, solutionUniqueName);
-            }
-            else {
-                // Web resource doesn't exist, create new
-                const webResource = {
-                    name: webResourceName,
-                    displayname: `Icon for ${entityMetadata.DisplayName?.UserLocalizedLabel?.Label || entityLogicalName}`,
-                    webresourcetype: 11, // SVG
-                    content: base64Content,
-                    description: `Fluent UI icon (${iconFileName}) for ${entityLogicalName} entity`
-                };
-                const webResourceResult = await this.createWebResource(webResource, solutionUniqueName);
-                webResourceId = webResourceResult.webresourceid;
-            }
-            // Step 7: Generate icon vector name
-            const iconVectorName = iconManager.generateIconVectorName(webResourceName);
-            // Step 8: Update entity metadata with icon reference
-            const entityUpdates = {
-                '@odata.type': 'Microsoft.Dynamics.CRM.EntityMetadata',
-                IconVectorName: iconVectorName
-            };
-            await this.updateEntity(metadataId, entityUpdates, solutionUniqueName);
-            // Step 9: Publish the web resource (component type 61)
-            await this.publishComponent(webResourceId, 61);
-            // Step 10: Publish the entity (component type 1)
-            await this.publishComponent(metadataId, 1);
-            // Log success
-            auditLogger.log({
-                operation: 'updateEntityIcon',
-                operationType: 'UPDATE',
-                componentType: 'Entity',
-                componentName: entityLogicalName,
-                success: true,
-                parameters: {
-                    iconFileName,
-                    webResourceName,
-                    webResourceId,
-                    iconVectorName
-                },
-                executionTimeMs: Date.now() - startTime
-            });
-            return {
-                success: true,
-                entityLogicalName,
-                entitySchemaName,
-                iconFileName,
-                webResourceId,
-                webResourceName,
-                iconVectorName,
-                message: 'Entity icon updated and published successfully. The icon should now be visible in the UI.'
-            };
-        }
-        catch (error) {
-            // Log failure
-            auditLogger.log({
-                operation: 'updateEntityIcon',
-                operationType: 'UPDATE',
-                componentType: 'Entity',
-                componentName: entityLogicalName,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw error;
-        }
-    }
-    /**
-     * 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
-     */
+        return this.entity.updateEntityIcon(entityLogicalName, iconFileName, {
+            getEntityMetadata: (name) => this.metadata.getEntityMetadata(name),
+            createWebResource: (resource, solution) => this.webResource.createWebResource(resource, solution),
+            updateWebResource: (id, updates, solution) => this.webResource.updateWebResource(id, updates, solution),
+            publishComponent: (id, componentType) => this.publishing.publishComponent(id, componentType),
+        }, solutionUniqueName);
+    }
+    // =====================================================
+    // ATTRIBUTE CUSTOMIZATION METHODS
+    // =====================================================
     async createAttribute(entityLogicalName, attributeDefinition, solutionUniqueName) {
-        const startTime = Date.now();
-        try {
-            // Validate attribute name against best practices
-            const schemaName = attributeDefinition.SchemaName || attributeDefinition.LogicalName;
-            const isLookup = attributeDefinition['@odata.type'] === 'Microsoft.Dynamics.CRM.LookupAttributeMetadata';
-            const nameValidation = bestPracticesValidator.validateAttributeName(schemaName, isLookup);
-            if (!nameValidation.isValid) {
-                const error = `Attribute name validation failed: ${nameValidation.issues.join(', ')}`;
-                auditLogger.log({
-                    operation: 'createAttribute',
-                    operationType: 'CREATE',
-                    componentType: 'Attribute',
-                    componentName: `${entityLogicalName}.${schemaName}`,
-                    success: false,
-                    error,
-                    executionTimeMs: Date.now() - startTime
-                });
-                throw new Error(error);
-            }
-            // Log warnings if any
-            if (nameValidation.warnings.length > 0) {
-                console.error(`[WARNING] Attribute name warnings: ${nameValidation.warnings.join(', ')}`);
-            }
-            // Validate boolean usage (best practice is to avoid booleans)
-            const isBoolean = attributeDefinition['@odata.type'] === 'Microsoft.Dynamics.CRM.BooleanAttributeMetadata';
-            if (isBoolean) {
-                const booleanValidation = bestPracticesValidator.validateBooleanUsage('Boolean', schemaName);
-                if (!booleanValidation.isValid) {
-                    console.error(`[WARNING] ${booleanValidation.warnings.join(', ')}`);
-                }
-            }
-            const headers = {};
-            if (solutionUniqueName) {
-                headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-            }
-            // Execute with rate limiting
-            const response = await rateLimiter.execute(async () => {
-                return await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes`, 'POST', attributeDefinition, headers);
-            });
-            // Log success
-            auditLogger.log({
-                operation: 'createAttribute',
-                operationType: 'CREATE',
-                componentType: 'Attribute',
-                componentName: `${entityLogicalName}.${schemaName}`,
-                success: true,
-                executionTimeMs: Date.now() - startTime
-            });
-            return response;
-        }
-        catch (error) {
-            // Log failure
-            const schemaName = attributeDefinition.SchemaName || attributeDefinition.LogicalName;
-            auditLogger.log({
-                operation: 'createAttribute',
-                operationType: 'CREATE',
-                componentType: 'Attribute',
-                componentName: `${entityLogicalName}.${schemaName}`,
-                success: false,
-                error: error.message,
-                executionTimeMs: Date.now() - startTime
-            });
-            throw error;
-        }
+        return this.attribute.createAttribute(entityLogicalName, attributeDefinition, solutionUniqueName);
     }
-    /**
-     * 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
-     */
     async updateAttribute(entityLogicalName, attributeLogicalName, updates, solutionUniqueName) {
-        const headers = {
-            'MSCRM.MergeLabels': 'true'
-        };
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        // First, get the existing attribute to retrieve its @odata.type and merge updates
-        const existingAttribute = await this.getEntityAttribute(entityLogicalName, attributeLogicalName);
-        // Merge the updates with required fields
-        const payload = {
-            ...updates,
-            '@odata.type': existingAttribute['@odata.type'],
-            LogicalName: attributeLogicalName,
-            AttributeType: existingAttribute.AttributeType
-        };
-        await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes(LogicalName='${attributeLogicalName}')`, 'PUT', payload, headers);
+        return this.attribute.updateAttribute(entityLogicalName, attributeLogicalName, updates, (entityName, attrName) => this.metadata.getEntityAttribute(entityName, attrName), solutionUniqueName);
     }
-    /**
-     * Delete an attribute
-     * @param entityLogicalName The logical name of the entity
-     * @param attributeMetadataId The MetadataId of the attribute to delete
-     */
     async deleteAttribute(entityLogicalName, attributeMetadataId) {
-        await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes(${attributeMetadataId})`, 'DELETE');
-    }
-    /**
-     * 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
-     */
-    async createGlobalOptionSetAttribute(entityLogicalName, attributeDefinition, solutionUniqueName) {
-        const headers = {};
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        // Ensure the attribute is of type PicklistAttributeMetadata with GlobalOptionSet
-        if (!attributeDefinition['@odata.type']) {
-            attributeDefinition['@odata.type'] = 'Microsoft.Dynamics.CRM.PicklistAttributeMetadata';
+        return this.attribute.deleteAttribute(entityLogicalName, attributeMetadataId);
+    }
+    async createGlobalOptionSetAttribute(entityLogicalName, schemaName, displayName, globalOptionSetName, options) {
+        const attributeDefinition = {
+            '@odata.type': 'Microsoft.Dynamics.CRM.PicklistAttributeMetadata',
+            SchemaName: schemaName,
+            DisplayName: {
+                '@odata.type': 'Microsoft.Dynamics.CRM.Label',
+                LocalizedLabels: [
+                    {
+                        '@odata.type': 'Microsoft.Dynamics.CRM.LocalizedLabel',
+                        Label: displayName,
+                        LanguageCode: 1033,
+                    },
+                ],
+            },
+            RequiredLevel: {
+                Value: options?.requiredLevel || 'None',
+            },
+            GlobalOptionSet: {
+                '@odata.type': 'Microsoft.Dynamics.CRM.OptionSetMetadata',
+                Name: globalOptionSetName,
+            },
+        };
+        if (options?.description) {
+            attributeDefinition.Description = {
+                '@odata.type': 'Microsoft.Dynamics.CRM.Label',
+                LocalizedLabels: [
+                    {
+                        '@odata.type': 'Microsoft.Dynamics.CRM.LocalizedLabel',
+                        Label: options.description,
+                        LanguageCode: 1033,
+                    },
+                ],
+            };
         }
-        return await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes`, 'POST', attributeDefinition, headers);
+        return this.attribute.createGlobalOptionSetAttribute(entityLogicalName, attributeDefinition, options?.solutionUniqueName);
     }
-    /**
-     * Create a one-to-many relationship
-     * @param relationshipDefinition The relationship definition
-     * @param solutionUniqueName Optional solution to add the relationship to
-     */
-    async createOneToManyRelationship(relationshipDefinition, solutionUniqueName) {
-        const headers = {};
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        const response = await this.makeRequest('api/data/v9.2/RelationshipDefinitions', 'POST', relationshipDefinition, headers);
-        return response;
+    // =====================================================
+    // RELATIONSHIP CUSTOMIZATION METHODS
+    // =====================================================
+    async createOneToManyRelationship(definition, solutionUniqueName) {
+        return this.relationship.createOneToManyRelationship(definition, solutionUniqueName);
     }
-    /**
-     * Create a many-to-many relationship
-     * @param relationshipDefinition The relationship definition
-     * @param solutionUniqueName Optional solution to add the relationship to
-     */
-    async createManyToManyRelationship(relationshipDefinition, solutionUniqueName) {
-        const headers = {};
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        const response = await this.makeRequest('api/data/v9.2/RelationshipDefinitions', 'POST', relationshipDefinition, headers);
-        return response;
+    async createManyToManyRelationship(definition, solutionUniqueName) {
+        return this.relationship.createManyToManyRelationship(definition, solutionUniqueName);
     }
-    /**
-     * Delete a relationship
-     * @param metadataId The MetadataId of the relationship to delete
-     */
     async deleteRelationship(metadataId) {
-        await this.makeRequest(`api/data/v9.2/RelationshipDefinitions(${metadataId})`, 'DELETE');
-    }
-    /**
-     * 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)
-     */
-    async updateRelationship(metadataId, updates) {
-        await this.makeRequest(`api/data/v9.2/RelationshipDefinitions(${metadataId})`, 'PUT', updates, { 'MSCRM.MergeLabels': 'true' });
-    }
-    /**
-     * Get detailed information about a relationship
-     * @param metadataId The MetadataId of the relationship
-     * @returns The relationship metadata
-     */
-    async getRelationshipDetails(metadataId) {
-        return await this.makeRequest(`api/data/v9.2/RelationshipDefinitions(${metadataId})`);
-    }
-    /**
-     * Publish all customizations
-     */
-    async publishAllCustomizations() {
-        await this.makeRequest('api/data/v9.2/PublishAllXml', 'POST', {});
-    }
-    /**
-     * Publish specific customizations
-     * @param parameterXml The ParameterXml specifying what to publish
-     */
-    async publishXml(parameterXml) {
-        await this.makeRequest('api/data/v9.2/PublishXml', 'POST', { ParameterXml: parameterXml });
-    }
-    /**
-     * Create a global option set
-     * @param optionSetDefinition The option set definition
-     * @param solutionUniqueName Optional solution to add the option set to
-     */
-    async createGlobalOptionSet(optionSetDefinition, solutionUniqueName) {
-        const headers = {};
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        const response = await this.makeRequest('api/data/v9.2/GlobalOptionSetDefinitions', 'POST', optionSetDefinition, headers);
-        return response;
+        return this.relationship.deleteRelationship(metadataId);
     }
-    /**
-     * Delete a global option set
-     * @param metadataId The MetadataId of the option set to delete
-     */
-    async deleteGlobalOptionSet(metadataId) {
-        await this.makeRequest(`api/data/v9.2/GlobalOptionSetDefinitions(${metadataId})`, 'DELETE');
+    async updateRelationship(metadataId, updates) {
+        return this.relationship.updateRelationship(metadataId, updates);
+    }
+    // =====================================================
+    // OPTION SET CUSTOMIZATION METHODS
+    // =====================================================
+    async createGlobalOptionSet(definition, solutionUniqueName) {
+        return this.optionSet.createGlobalOptionSet(definition, solutionUniqueName);
     }
-    // ===== Phase 2: UI Components (Forms, Views, Option Sets) =====
-    /**
-     * Update a global option set
-     */
     async updateGlobalOptionSet(metadataId, updates, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        await this.makeRequest(`api/data/v9.2/GlobalOptionSetDefinitions(${metadataId})`, 'PUT', updates, headers);
+        return this.optionSet.updateGlobalOptionSet(metadataId, updates, solutionUniqueName);
     }
-    /**
-     * Add a value to a global option set
-     */
     async addOptionSetValue(optionSetName, value, label, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        return await this.makeRequest(`api/data/v9.2/InsertOptionValue`, 'POST', {
-            OptionSetName: optionSetName,
-            Value: value,
-            Label: {
-                LocalizedLabels: [{ Label: label, LanguageCode: 1033 }]
-            }
-        }, headers);
+        return this.optionSet.addOptionSetValue(optionSetName, value, label, solutionUniqueName);
     }
-    /**
-     * Update an option set value
-     */
     async updateOptionSetValue(optionSetName, value, label, solutionUniqueName) {
-        const headers = { 'MSCRM.MergeLabels': 'true' };
-        if (solutionUniqueName) {
-            headers['MSCRM.SolutionUniqueName'] = solutionUniqueName;
-        }
-        await this.makeRequest(`api/data/v9.2/UpdateOptionValue`, 'POST', {
-            OptionSetName: optionSetName,
-            Value: value,
-            Label: {
-                LocalizedLabels: [{ Label: label, LanguageCode: 1033 }]
-            },
-            MergeLabels: true
-        }, headers);
+        return this.optionSet.updateOptionSetValue(optionSetName, value, label, solutionUniqueName);
     }
-    /**
-     * Delete an option set value
-     */
     async deleteOptionSetValue(optionSetName, value) {
-        await this.makeRequest(`api/data/v9.2/DeleteOptionValue`, 'POST', {
-            OptionSetName: optionSetName,
-            Value: value
-        });
+        return this.optionSet.deleteOptionSetValue(optionSetName, value);
     }
-    /**
-     * Reorder option set values
-     */
     async reorderOptionSetValues(optionSetName, values, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        await this.makeRequest(`api/data/v9.2/OrderOption`, 'POST', {
-            OptionSetName: optionSetName,
-            Values: values
-        }, headers);
-    }
-    /**
-     * Create a form (systemform)
-     */
-    async createForm(form, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        return await this.makeRequest('api/data/v9.2/systemforms', 'POST', form, headers);
-    }
-    /**
-     * Update a form
-     */
-    async updateForm(formId, updates, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        await this.makeRequest(`api/data/v9.2/systemforms(${formId})`, 'PATCH', updates, headers);
+        return this.optionSet.reorderOptionSetValues(optionSetName, values, solutionUniqueName);
     }
-    /**
-     * Delete a form
-     */
-    async deleteForm(formId) {
-        await this.makeRequest(`api/data/v9.2/systemforms(${formId})`, 'DELETE');
-    }
-    /**
-     * Get forms for an entity
-     */
+    // =====================================================
+    // FORM CUSTOMIZATION METHODS
+    // =====================================================
     async getForms(entityLogicalName) {
-        return await this.makeRequest(`api/data/v9.2/systemforms?$filter=objecttypecode eq '${entityLogicalName}'&$orderby=type`);
-    }
-    /**
-     * Create a view (savedquery)
-     */
-    async createView(view, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        return await this.makeRequest('api/data/v9.2/savedqueries', 'POST', view, headers);
+        return this.form.getForms(entityLogicalName);
+    }
+    async createForm(name, entityLogicalName, formType, formXml, options) {
+        const formData = {
+            name,
+            objecttypecode: entityLogicalName,
+            type: this.getFormTypeCode(formType),
+            formxml: formXml,
+        };
+        if (options?.description) {
+            formData.description = options.description;
+        }
+        return this.form.createForm(formData, options?.solutionUniqueName);
     }
-    /**
-     * Update a view
-     */
-    async updateView(viewId, updates, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        await this.makeRequest(`api/data/v9.2/savedqueries(${viewId})`, 'PATCH', updates, headers);
+    getFormTypeCode(formType) {
+        const typeMap = {
+            Main: 2,
+            QuickCreate: 7,
+            QuickView: 6,
+            Card: 11,
+        };
+        return typeMap[formType] || 2;
     }
-    /**
-     * Delete a view
-     */
-    async deleteView(viewId) {
-        await this.makeRequest(`api/data/v9.2/savedqueries(${viewId})`, 'DELETE');
+    async updateForm(formId, updates, solutionUniqueName) {
+        return this.form.updateForm(formId, updates, solutionUniqueName);
     }
-    /**
-     * Get views for an entity
-     */
-    async getViews(entityLogicalName) {
-        return await this.makeRequest(`api/data/v9.2/savedqueries?$filter=returnedtypecode eq '${entityLogicalName}'&$orderby=querytype`);
+    async deleteForm(formId) {
+        return this.form.deleteForm(formId);
     }
-    /**
-     * Activate a form (set statecode=1)
-     * @param formId The systemformid (GUID)
-     */
     async activateForm(formId) {
-        await this.makeRequest(`api/data/v9.2/systemforms(${formId})`, 'PATCH', { statecode: 1, statuscode: 1 });
+        return this.form.activateForm(formId);
     }
-    /**
-     * Deactivate a form (set statecode=0)
-     * @param formId The systemformid (GUID)
-     */
     async deactivateForm(formId) {
-        await this.makeRequest(`api/data/v9.2/systemforms(${formId})`, 'PATCH', { statecode: 0, statuscode: 2 });
+        return this.form.deactivateForm(formId);
     }
-    /**
-     * Set a view as the default view for its entity
-     * @param viewId The savedqueryid (GUID)
-     */
-    async setDefaultView(viewId) {
-        await this.makeRequest(`api/data/v9.2/savedqueries(${viewId})`, 'PATCH', { isdefault: true });
+    // =====================================================
+    // VIEW CUSTOMIZATION METHODS
+    // =====================================================
+    async getViews(entityLogicalName) {
+        return this.view.getViews(entityLogicalName);
     }
-    /**
-     * Get the FetchXML from a view
-     * @param viewId The savedqueryid (GUID)
-     * @returns The view with FetchXML
-     */
     async getViewFetchXml(viewId) {
-        return await this.makeRequest(`api/data/v9.2/savedqueries(${viewId})?$select=fetchxml,name,returnedtypecode,querytype`);
+        return this.view.getViewFetchXml(viewId);
+    }
+    async createView(name, entityLogicalName, fetchXml, layoutXml, options) {
+        const viewData = {
+            name,
+            returnedtypecode: entityLogicalName,
+            fetchxml: fetchXml,
+            layoutxml: layoutXml,
+            querytype: options?.queryType ?? 0,
+        };
+        if (options?.description) {
+            viewData.description = options.description;
+        }
+        if (options?.isDefault !== undefined) {
+            viewData.isdefault = options.isDefault;
+        }
+        return this.view.createView(viewData, options?.solutionUniqueName);
     }
-    // ===== Phase 3: Advanced Customizations (Web Resources) =====
-    /**
-     * Create a web resource
-     */
-    async createWebResource(webResource, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        return await this.makeRequest('api/data/v9.2/webresourceset', 'POST', webResource, headers);
+    async updateView(viewId, updates, solutionUniqueName) {
+        return this.view.updateView(viewId, updates, solutionUniqueName);
     }
-    /**
-     * Update a web resource
-     */
-    async updateWebResource(webResourceId, updates, solutionUniqueName) {
-        const headers = solutionUniqueName ? { 'MSCRM.SolutionUniqueName': solutionUniqueName } : undefined;
-        await this.makeRequest(`api/data/v9.2/webresourceset(${webResourceId})`, 'PATCH', updates, headers);
+    async deleteView(viewId) {
+        return this.view.deleteView(viewId);
     }
-    /**
-     * Delete a web resource
-     */
-    async deleteWebResource(webResourceId) {
-        await this.makeRequest(`api/data/v9.2/webresourceset(${webResourceId})`, 'DELETE');
+    async setDefaultView(viewId) {
+        return this.view.setDefaultView(viewId);
     }
-    /**
-     * Get web resource
-     */
+    // =====================================================
+    // WEB RESOURCE CUSTOMIZATION METHODS
+    // =====================================================
     async getWebResource(webResourceId) {
-        return await this.makeRequest(`api/data/v9.2/webresourceset(${webResourceId})`);
+        return this.webResource.getWebResource(webResourceId);
     }
-    /**
-     * Get web resources by name pattern
-     */
     async getWebResources(nameFilter) {
-        const filter = nameFilter ? `?$filter=contains(name,'${nameFilter}')` : '';
-        return await this.makeRequest(`api/data/v9.2/webresourceset${filter}`);
-    }
-    /**
-     * Get web resource content (base64 encoded)
-     * @param webResourceId The webresourceid (GUID)
-     * @returns The web resource with content field
-     */
-    async getWebResourceContent(webResourceId) {
-        return await this.makeRequest(`api/data/v9.2/webresourceset(${webResourceId})?$select=content,name,webresourcetype`);
+        return this.webResource.getWebResources(nameFilter);
+    }
+    async createWebResource(name, displayName, webResourceType, content, options) {
+        const webResourceData = {
+            name,
+            displayname: displayName,
+            webresourcetype: webResourceType,
+            content,
+        };
+        if (options?.description) {
+            webResourceData.description = options.description;
+        }
+        return this.webResource.createWebResource(webResourceData, options?.solutionUniqueName);
     }
-    /**
-     * Get web resource dependencies
-     * @param webResourceId The webresourceid (GUID)
-     * @returns List of dependencies
-     */
-    async getWebResourceDependencies(webResourceId) {
-        return await this.makeRequest(`api/data/v9.2/webresourceset(${webResourceId})/dependencies`);
+    async updateWebResource(webResourceId, updates, solutionUniqueName) {
+        return this.webResource.updateWebResource(webResourceId, updates, solutionUniqueName);
     }
-    // ===== Phase 4: Solution Management =====
-    /**
-     * Create a publisher
-     */
-    async createPublisher(publisher) {
-        return await this.makeRequest('api/data/v9.2/publishers', 'POST', publisher);
+    async deleteWebResource(webResourceId) {
+        return this.webResource.deleteWebResource(webResourceId);
     }
-    /**
-     * Get publishers
-     */
+    // =====================================================
+    // SOLUTION CUSTOMIZATION METHODS
+    // =====================================================
     async getPublishers() {
-        return await this.makeRequest('api/data/v9.2/publishers?$filter=isreadonly eq false');
-    }
-    /**
-     * Create a solution
-     */
-    async createSolution(solution) {
-        return await this.makeRequest('api/data/v9.2/solutions', 'POST', solution);
+        return this.solution.getPublishers();
+    }
+    async createPublisher(uniqueName, friendlyName, customizationPrefix, customizationOptionValuePrefix, description) {
+        const publisherData = {
+            uniquename: uniqueName,
+            friendlyname: friendlyName,
+            customizationprefix: customizationPrefix,
+            customizationoptionvalueprefix: customizationOptionValuePrefix,
+        };
+        if (description) {
+            publisherData.description = description;
+        }
+        return this.solution.createPublisher(publisherData);
     }
-    /**
-     * Get solutions
-     */
     async getSolutions() {
-        return await this.makeRequest('api/data/v9.2/solutions?$filter=isvisible eq true&$orderby=createdon desc');
+        return this.solution.getSolutions();
     }
-    /**
-     * Get solution by unique name
-     */
     async getSolution(uniqueName) {
-        const result = await this.makeRequest(`api/data/v9.2/solutions?$filter=uniquename eq '${uniqueName}'&$top=1`);
-        return result.value && result.value.length > 0 ? result.value[0] : null;
+        return this.solution.getSolution(uniqueName);
+    }
+    async createSolution(uniqueName, friendlyName, version, publisherId, description) {
+        const solutionData = {
+            uniquename: uniqueName,
+            friendlyname: friendlyName,
+            version: version,
+            'publisherid@odata.bind': `/publishers(${publisherId})`,
+        };
+        if (description) {
+            solutionData.description = description;
+        }
+        return this.solution.createSolution(solutionData);
     }
-    /**
-     * Add component to solution
-     */
-    async addComponentToSolution(solutionUniqueName, componentId, componentType, addRequiredComponents = true, includedComponentSettingsValues) {
-        await this.makeRequest('api/data/v9.2/AddSolutionComponent', 'POST', {
-            SolutionUniqueName: solutionUniqueName,
-            ComponentId: componentId,
-            ComponentType: componentType,
-            AddRequiredComponents: addRequiredComponents,
-            IncludedComponentSettingsValues: includedComponentSettingsValues
-        });
+    async getSolutionComponents(solutionUniqueName) {
+        return this.solution.getSolutionComponents(solutionUniqueName);
     }
-    /**
-     * Remove component from solution
-     */
-    async removeComponentFromSolution(solutionUniqueName, componentId, componentType) {
-        await this.makeRequest('api/data/v9.2/RemoveSolutionComponent', 'POST', {
-            SolutionUniqueName: solutionUniqueName,
-            ComponentId: componentId,
-            ComponentType: componentType
-        });
+    async addComponentToSolution(solutionUniqueName, componentId, componentType, addRequiredComponents) {
+        return this.solution.addComponentToSolution(solutionUniqueName, componentId, componentType, addRequiredComponents);
     }
-    /**
-     * Get solution components
-     */
-    async getSolutionComponents(solutionUniqueName) {
-        const solution = await this.getSolution(solutionUniqueName);
-        if (!solution) {
-            throw new Error(`Solution '${solutionUniqueName}' not found`);
-        }
-        return await this.makeRequest(`api/data/v9.2/solutioncomponents?$filter=_solutionid_value eq ${solution.solutionid}&$orderby=componenttype`);
+    async removeComponentFromSolution(solutionUniqueName, componentId, componentType) {
+        return this.solution.removeComponentFromSolution(solutionUniqueName, componentId, componentType);
     }
-    /**
-     * Export solution
-     */
-    async exportSolution(solutionName, managed = false) {
-        return await this.makeRequest('api/data/v9.2/ExportSolution', 'POST', {
-            SolutionName: solutionName,
-            Managed: managed,
-            ExportAutoNumberingSettings: true,
-            ExportCalendarSettings: true,
-            ExportCustomizationSettings: true,
-            ExportEmailTrackingSettings: true,
-            ExportGeneralSettings: true,
-            ExportMarketingSettings: true,
-            ExportOutlookSynchronizationSettings: true,
-            ExportRelationshipRoles: true,
-            ExportIsvConfig: true,
-            ExportSales: true,
-            ExportExternalApplications: true
-        });
+    async exportSolution(solutionName, managed) {
+        return this.solution.exportSolution(solutionName, managed ?? false);
     }
-    /**
-     * Import solution
-     */
-    async importSolution(customizationFile, publishWorkflows = true, overwriteUnmanagedCustomizations = false) {
-        return await this.makeRequest('api/data/v9.2/ImportSolution', 'POST', {
-            CustomizationFile: customizationFile,
-            PublishWorkflows: publishWorkflows,
-            OverwriteUnmanagedCustomizations: overwriteUnmanagedCustomizations,
-            SkipProductUpdateDependencies: false,
-            HoldingSolution: false,
-            ImportJobId: this.generateGuid()
-        });
+    async importSolution(customizationFile, overwriteUnmanagedCustomizations, publishWorkflows) {
+        return this.solution.importSolution(customizationFile, overwriteUnmanagedCustomizations, publishWorkflows);
     }
-    /**
-     * Delete a solution
-     */
-    async deleteSolution(solutionId) {
-        await this.makeRequest(`api/data/v9.2/solutions(${solutionId})`, 'DELETE');
+    // =====================================================
+    // PUBLISHING METHODS
+    // =====================================================
+    async publishAllCustomizations() {
+        return this.publishing.publishAllCustomizations();
     }
-    // ===== Phase 5: Publishing & Validation =====
-    /**
-     * Publish specific entity
-     */
     async publishEntity(entityLogicalName) {
-        const parameterXml = `<importexportxml><entities><entity>${entityLogicalName}</entity></entities></importexportxml>`;
-        await this.publishXml(parameterXml);
+        return this.publishing.publishEntity(entityLogicalName);
     }
-    /**
-     * Publish specific component
-     */
-    async publishComponent(componentId, componentType) {
-        const typeMap = {
-            1: 'entity',
-            2: 'attribute',
-            9: 'optionset',
-            24: 'form',
-            26: 'savedquery',
-            29: 'workflow',
-            60: 'systemform',
-            61: 'webresource'
-        };
-        const componentTypeName = typeMap[componentType] || 'component';
-        const parameterXml = `<importexportxml><${componentTypeName}s><${componentTypeName}>${componentId}</${componentTypeName}></${componentTypeName}s></importexportxml>`;
-        await this.publishXml(parameterXml);
+    // =====================================================
+    // DEPENDENCY METHODS
+    // =====================================================
+    async checkDependencies(componentId, componentType) {
+        return this.dependency.checkDependencies(componentId, componentType);
     }
-    /**
-     * Check for unpublished customizations
-     */
-    async checkUnpublishedChanges() {
-        // Query for unpublished customizations using RetrieveUnpublished
-        return await this.makeRequest('api/data/v9.2/RetrieveUnpublished', 'POST', {});
+    async checkDeleteEligibility(componentId, componentType) {
+        return this.dependency.checkDeleteEligibility(componentId, componentType);
     }
-    /**
-     * Check component dependencies
-     */
-    async checkDependencies(componentId, componentType) {
-        return await this.makeRequest('api/data/v9.2/RetrieveDependenciesForDelete', 'POST', {
-            ObjectId: componentId,
-            ComponentType: componentType
+    // =====================================================
+    // PLUGIN DEPLOYMENT METHODS
+    // =====================================================
+    async extractAssemblyVersion(assemblyPath) {
+        return this.pluginDeployment.extractAssemblyVersion(assemblyPath);
+    }
+    async queryPluginTypeByTypename(typename) {
+        return this.pluginDeployment.queryPluginTypeByTypename(typename);
+    }
+    async queryPluginAssemblyByName(assemblyName) {
+        return this.pluginDeployment.queryPluginAssemblyByName(assemblyName);
+    }
+    async getPluginTypesForAssembly(assemblyId) {
+        return this.pluginDeployment.getPluginTypesForAssembly(assemblyId);
+    }
+    async resolveSdkMessageAndFilter(messageName, primaryEntity) {
+        return this.pluginDeployment.resolveSdkMessageAndFilter(messageName, primaryEntity);
+    }
+    async createPluginAssembly(options) {
+        return this.pluginDeployment.createPluginAssembly({
+            name: options.name,
+            content: options.content,
+            version: options.version,
+            description: options.description,
+            isolationMode: options.isolationMode,
+            solutionUniqueName: options.solutionUniqueName,
         });
     }
-    /**
-     * Check if component can be deleted
-     */
-    async checkDeleteEligibility(componentId, componentType) {
-        try {
-            const result = await this.checkDependencies(componentId, componentType);
-            const dependencies = result.EntityCollection?.Entities || [];
-            return {
-                canDelete: dependencies.length === 0,
-                dependencies: dependencies
-            };
-        }
-        catch (error) {
-            return {
-                canDelete: false,
-                dependencies: []
-            };
-        }
+    async updatePluginAssembly(assemblyId, content, version, solutionUniqueName) {
+        return this.pluginDeployment.updatePluginAssembly(assemblyId, content, version, solutionUniqueName);
     }
-    /**
-     * Preview unpublished changes
-     * Returns all components that have unpublished customizations
-     */
-    async previewUnpublishedChanges() {
-        // Use RetrieveUnpublished action to get unpublished changes
-        return await this.makeRequest('api/data/v9.2/RetrieveUnpublished', 'POST', {});
+    async deletePluginAssembly(assemblyId) {
+        return this.pluginDeployment.deletePluginAssembly(assemblyId);
     }
-    /**
-     * Check dependencies for a specific component
-     * @param componentId The component ID (GUID)
-     * @param componentType The component type code
-     * @returns Dependency information
-     */
-    async checkComponentDependencies(componentId, componentType) {
-        // This is an alias for checkDependencies for consistency
-        return await this.checkDependencies(componentId, componentType);
+    async deletePluginStep(stepId) {
+        return this.pluginDeployment.deletePluginStep(stepId);
     }
-    /**
-     * Validate solution integrity
-     * Checks for missing dependencies and other issues
-     * @param solutionUniqueName The unique name of the solution
-     * @returns Validation results
-     */
-    async validateSolutionIntegrity(solutionUniqueName) {
-        // Get solution components
-        const components = await this.getSolutionComponents(solutionUniqueName);
-        const issues = [];
-        const warnings = [];
-        // Check each component for dependencies
-        for (const component of components.value || []) {
-            try {
-                const deps = await this.checkDependencies(component.objectid, component.componenttype);
-                const dependencies = deps.EntityCollection?.Entities || [];
-                const missingDeps = dependencies.filter((d) => d.Attributes?.ismissing === true);
-                if (missingDeps.length > 0) {
-                    issues.push({
-                        componentId: component.objectid,
-                        componentType: component.componenttype,
-                        missingDependencies: missingDeps
-                    });
-                }
-            }
-            catch (error) {
-                warnings.push({
-                    componentId: component.objectid,
-                    componentType: component.componenttype,
-                    error: 'Could not check dependencies'
-                });
-            }
-        }
-        return {
-            isValid: issues.length === 0,
-            issues,
-            warnings
-        };
+    async registerPluginStep(config) {
+        return this.pluginDeployment.registerPluginStep(config);
     }
-    /**
-     * Validate schema name
-     */
-    validateSchemaName(schemaName, prefix) {
-        const errors = [];
-        // Check if starts with prefix
-        if (!schemaName.startsWith(prefix)) {
-            errors.push(`Schema name must start with prefix '${prefix}'`);
-        }
-        // Check for invalid characters
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
-            errors.push('Schema name must start with a letter or underscore and contain only letters, numbers, and underscores');
-        }
-        // Check length (max 64 characters for most components)
-        if (schemaName.length > 64) {
-            errors.push('Schema name must be 64 characters or less');
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
+    async registerPluginImage(config) {
+        return this.pluginDeployment.registerPluginImage(config);
     }
-    /**
-     * Get entity customization information
-     */
-    async getEntityCustomizationInfo(entityLogicalName) {
-        return await this.makeRequest(`api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')?$select=IsCustomizable,IsManaged,IsCustomEntity`);
+    // =====================================================
+    // APP MANAGEMENT METHODS
+    // =====================================================
+    async createSimpleSitemap(config, solutionUniqueName) {
+        // Cast config to the expected type - caller is responsible for correct structure
+        return this.appManagement.createSimpleSitemap(config, solutionUniqueName);
     }
-    /**
-     * Check if entity has dependencies
-     */
-    async checkEntityDependencies(entityLogicalName) {
-        // First get the metadata ID
-        const entityMetadata = await this.getEntityMetadata(entityLogicalName);
-        if (!entityMetadata.MetadataId) {
-            throw new Error(`Could not find MetadataId for entity '${entityLogicalName}'`);
-        }
-        // Component type 1 = Entity
-        return await this.checkDependencies(entityMetadata.MetadataId, 1);
+    async addEntitiesToApp(appId, entityNames) {
+        return this.appManagement.addEntitiesToApp(appId, entityNames);
     }
-    /**
-     * Helper to generate GUID
-     */
-    generateGuid() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            const r = Math.random() * 16 | 0;
-            const v = c === 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
+    async validateApp(appId) {
+        return this.appManagement.validateApp(appId);
     }
-    // ============================================================
-    // PLUGIN DEPLOYMENT METHODS
-    // ============================================================
-    /**
-     * Extract assembly version from .NET DLL using PE header parsing
-     * @param assemblyPath - Path to the compiled .NET assembly (DLL)
-     * @returns Version string (e.g., "1.0.0.0")
-     */
-    async extractAssemblyVersion(assemblyPath) {
-        try {
-            // Dynamically import fs/promises for ESM compatibility
-            const fs = await import('fs/promises');
-            // Normalize path for cross-platform compatibility (Windows/WSL)
-            const normalizedPath = assemblyPath.replace(/\\/g, '/');
-            // Read the DLL file
-            const buffer = await fs.readFile(normalizedPath);
-            // Validate DLL format (should start with "MZ" header)
-            const header = buffer.toString('utf8', 0, 2);
-            if (header !== 'MZ') {
-                console.error('Invalid .NET assembly format - using default version');
-                return '1.0.0.0';
-            }
-            // Try to find version resource in PE header
-            // This is a simplified version - for production, you might want a more robust parser
-            // For now, we'll return a default version and let the user specify if needed
-            // Search for common version patterns in the assembly
-            const bufferStr = buffer.toString('utf16le');
-            const versionMatch = bufferStr.match(/\d+\.\d+\.\d+\.\d+/);
-            if (versionMatch) {
-                return versionMatch[0];
-            }
-            // Fallback to default version
-            console.error('Could not extract version from assembly - using default 1.0.0.0');
-            return '1.0.0.0';
-        }
-        catch (error) {
-            console.error('Error extracting assembly version:', error.message);
-            return '1.0.0.0';
-        }
+    async publishApp(appId) {
+        // publishApp needs a callback for publishXml
+        return this.appManagement.publishApp(appId, (parameterXml) => this.publishing.publishXml(parameterXml));
     }
-    /**
-     * Query plugin type by typename
-     * @param typename - Plugin type typename (e.g., "MyNamespace.ContactPlugin")
-     * @returns Plugin type ID
-     */
-    async queryPluginTypeByTypename(typename) {
-        try {
-            const response = await this.makeRequest(`api/data/v9.2/plugintypes?$filter=typename eq '${typename}'&$select=plugintypeid`, 'GET');
-            if (!response.value || response.value.length === 0) {
-                throw new Error(`Plugin type '${typename}' not found. ` +
-                    `Did you upload the assembly first? Use 'create-plugin-assembly' tool.`);
-            }
-            return response.value[0].plugintypeid;
-        }
-        catch (error) {
-            throw new Error(`Failed to query plugin type: ${error.message}`);
-        }
+    // =====================================================
+    // WORKFLOW MANAGEMENT METHODS
+    // =====================================================
+    async deactivateWorkflow(workflowId) {
+        return this.workflowManagement.deactivateWorkflow(workflowId);
     }
-    /**
-     * Query plugin assembly by name
-     * @param assemblyName - Assembly name
-     * @returns Plugin assembly ID or null if not found
-     */
-    async queryPluginAssemblyByName(assemblyName) {
-        try {
-            const response = await this.makeRequest(`api/data/v9.2/pluginassemblies?$filter=name eq '${assemblyName}'&$select=pluginassemblyid`, 'GET');
-            if (!response.value || response.value.length === 0) {
-                return null;
-            }
-            return response.value[0].pluginassemblyid;
-        }
-        catch (error) {
-            throw new Error(`Failed to query plugin assembly: ${error.message}`);
-        }
+    async activateWorkflow(workflowId) {
+        return this.workflowManagement.activateWorkflow(workflowId);
     }
-    /**
-     * Get plugin types for an existing assembly
-     * Used to retrieve type information after an assembly update
-     * @param assemblyId - Assembly GUID
-     * @returns Array of plugin type information
-     */
-    async getPluginTypesForAssembly(assemblyId) {
-        try {
-            const types = await this.makeRequest(`api/data/v9.2/plugintypes?$filter=_pluginassemblyid_value eq ${assemblyId}&$select=plugintypeid,typename,friendlyname`, 'GET');
-            return types.value.map((t) => ({
-                pluginTypeId: t.plugintypeid,
-                typeName: t.typename,
-                friendlyName: t.friendlyname
-            }));
-        }
-        catch (error) {
-            throw new Error(`Failed to get plugin types for assembly: ${error.message}`);
-        }
+    async updateWorkflowDescription(workflowId, description) {
+        return this.workflowManagement.updateWorkflowDescription(workflowId, description);
+    }
+    async updateFlowDescription(flowId, description) {
+        return this.workflowManagement.updateFlowDescription(flowId, description);
     }
     /**
-     * Resolve SDK Message and Filter IDs for plugin step registration
-     * @param messageName - SDK message name (e.g., "Create", "Update", "Delete")
-     * @param entityName - Entity logical name (e.g., "contact", "account")
-     * @returns Object containing messageId and filterId
+     * Adapter function to convert FlowService.parseFlowSummary output to expected format
      */
-    async resolveSdkMessageAndFilter(messageName, entityName) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Step 1: Get SDK Message ID
-            const messages = await this.makeRequest(`api/data/v9.2/sdkmessages?$filter=name eq '${messageName}'&$select=sdkmessageid,name`, 'GET');
-            if (!messages.value || messages.value.length === 0) {
-                throw new Error(`SDK message '${messageName}' not found. ` +
-                    `Common messages: Create, Update, Delete, SetState, Assign, Merge, Retrieve, RetrieveMultiple`);
-            }
-            const messageId = messages.value[0].sdkmessageid;
-            // Step 2: Get SDK Message Filter ID
-            const filters = await this.makeRequest(`api/data/v9.2/sdkmessagefilters?$filter=sdkmessageid/sdkmessageid eq ${messageId} and primaryobjecttypecode eq '${entityName}'&$select=sdkmessagefilterid`, 'GET');
-            if (!filters.value || filters.value.length === 0) {
-                throw new Error(`SDK message filter not found for message '${messageName}' on entity '${entityName}'. ` +
-                    `Verify the entity supports this message.`);
-            }
-            const filterId = filters.value[0].sdkmessagefilterid;
-            auditLogger.log({
-                operation: 'resolve-sdk-message-filter',
-                operationType: 'READ',
-                componentType: 'SdkMessage',
-                success: true,
-                parameters: { messageName, entityName, messageId, filterId },
-                executionTimeMs: timer(),
-            });
-            return { messageId, filterId };
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'resolve-sdk-message-filter',
-                operationType: 'READ',
-                componentType: 'SdkMessage',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    adaptFlowSummary(flowDef) {
+        const summary = this.flow.parseFlowSummary(flowDef);
+        return {
+            tablesModified: Array.from(summary.tablesModified || []),
+            triggerInfo: summary.triggerInfo || 'manual',
+            triggerFields: summary.triggerFields || [],
+            actions: summary.actions || [],
+            customApisCalled: Array.from(summary.customApisCalled || []),
+        };
     }
     /**
-     * Create a new plugin assembly in Dataverse
-     * @param options - Assembly creation options
-     * @returns Created assembly ID and plugin types
+     * Adapter function to convert WorkflowService.parseWorkflowXamlSummary output to expected format
      */
-    async createPluginAssembly(options) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Validate DLL size (16MB Dataverse limit)
-            const dllSize = Buffer.from(options.content, 'base64').length;
-            const maxSize = 16 * 1024 * 1024; // 16MB
-            if (dllSize > maxSize) {
-                throw new Error(`Assembly exceeds 16MB limit (current: ${(dllSize / 1024 / 1024).toFixed(2)}MB). ` +
-                    `Remove unused dependencies or split into multiple assemblies.`);
-            }
-            // Create assembly payload
-            const assemblyData = {
-                name: options.name,
-                content: options.content,
-                version: options.version,
-                isolationmode: options.isolationMode ?? 2, // Default to Sandbox for security
-                sourcetype: options.sourceType ?? 0, // Default to Database
-                culture: 'neutral'
-            };
-            if (options.description) {
-                assemblyData.description = options.description;
-            }
-            // Upload assembly to Dataverse
-            const createResponse = await this.makeRequest('api/data/v9.2/pluginassemblies', 'POST', assemblyData, { 'Prefer': 'return=representation' });
-            // Extract assembly ID from response header or body
-            const pluginAssemblyId = createResponse.pluginassemblyid || createResponse.id;
-            if (!pluginAssemblyId) {
-                throw new Error('Plugin assembly created but ID not returned');
-            }
-            // Add to solution if specified
-            if (options.solutionUniqueName) {
-                await this.addComponentToSolution(options.solutionUniqueName, pluginAssemblyId, 91 // Component type 91 = PluginAssembly
-                );
-            }
-            // Poll for plugin types (Dataverse creates them asynchronously)
-            // Wait up to 60 seconds with 2-second intervals
-            const pluginTypes = [];
-            const maxAttempts = 30; // 30 attempts * 2 seconds = 60 seconds total
-            const pollInterval = 2000; // 2 seconds
-            for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                // Wait before polling (except first attempt)
-                if (attempt > 0) {
-                    await new Promise(resolve => setTimeout(resolve, pollInterval));
-                }
-                // Query for plugin types
-                const types = await this.makeRequest(`api/data/v9.2/plugintypes?$filter=_pluginassemblyid_value eq ${pluginAssemblyId}&$select=plugintypeid,typename,friendlyname`, 'GET');
-                if (types.value && types.value.length > 0) {
-                    pluginTypes.push(...types.value.map((t) => ({
-                        pluginTypeId: t.plugintypeid,
-                        typeName: t.typename,
-                        friendlyName: t.friendlyname
-                    })));
-                    break;
-                }
-            }
-            if (pluginTypes.length === 0) {
-                throw new Error(`Plugin types not created after ${maxAttempts * pollInterval / 1000} seconds. ` +
-                    `Dataverse may be experiencing delays processing the assembly. ` +
-                    `Please check System Jobs in Power Platform admin center and retry. ` +
-                    `Assembly ID: ${pluginAssemblyId}`);
-            }
-            auditLogger.log({
-                operation: 'create-plugin-assembly',
-                operationType: 'CREATE',
-                componentId: pluginAssemblyId,
-                componentType: 'PluginAssembly',
-                success: true,
-                parameters: {
-                    name: options.name,
-                    version: options.version,
-                    size: dllSize,
-                    pluginTypeCount: pluginTypes.length
-                },
-                executionTimeMs: timer(),
-            });
-            return {
-                pluginAssemblyId,
-                pluginTypes
-            };
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'create-plugin-assembly',
-                operationType: 'CREATE',
-                componentName: options.name,
-                componentType: 'PluginAssembly',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    adaptWorkflowSummary(xaml) {
+        const summary = this.workflow.parseWorkflowXamlSummary(xaml);
+        const activities = summary.activities || [];
+        const getCount = (type) => {
+            const activity = activities.find(a => a.type === type);
+            return activity?.count || 0;
+        };
+        return {
+            tablesModified: Array.from(summary.tablesModified || []),
+            triggerInfo: summary.triggerInfo || 'manual',
+            triggerFields: summary.triggerFields || [],
+            createEntityCount: getCount('CreateEntity'),
+            updateEntityCount: getCount('UpdateEntity'),
+            assignEntityCount: getCount('AssignEntity'),
+            setStateCount: getCount('SetState'),
+        };
+    }
+    async documentAutomation(automationId, type) {
+        return this.workflowManagement.documentAutomation(automationId, type, (def) => this.adaptFlowSummary(def), (xaml) => this.adaptWorkflowSummary(xaml));
+    }
+    async documentWorkflowSafe(workflowId, type) {
+        return this.workflowManagement.documentWorkflowSafe(workflowId, type, (def) => this.adaptFlowSummary(def), (xaml) => this.adaptWorkflowSummary(xaml));
     }
     /**
-     * Update an existing plugin assembly with new DLL content
-     * @param assemblyId - Assembly GUID
-     * @param content - Base64-encoded DLL content
-     * @param version - New version string
-     * @param solutionUniqueName - Optional solution context
+     * Create a new Power Automate flow from an existing template flow
      */
-    async updatePluginAssembly(assemblyId, content, version, solutionUniqueName) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Validate DLL size
-            const dllSize = Buffer.from(content, 'base64').length;
-            const maxSize = 16 * 1024 * 1024;
-            if (dllSize > maxSize) {
-                throw new Error(`Assembly exceeds 16MB limit (current: ${(dllSize / 1024 / 1024).toFixed(2)}MB)`);
-            }
-            // Update assembly
-            await this.makeRequest(`api/data/v9.2/pluginassemblies(${assemblyId})`, 'PATCH', {
-                content,
-                version
-            });
-            // Add to solution if specified
-            if (solutionUniqueName) {
-                await this.addComponentToSolution(solutionUniqueName, assemblyId, 91 // Component type 91 = PluginAssembly
-                );
-            }
-            auditLogger.log({
-                operation: 'update-plugin-assembly',
-                operationType: 'UPDATE',
-                componentId: assemblyId,
-                componentType: 'PluginAssembly',
-                success: true,
-                parameters: { assemblyId, version, size: dllSize },
-                executionTimeMs: timer(),
-            });
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'update-plugin-assembly',
-                operationType: 'UPDATE',
-                componentId: assemblyId,
-                componentType: 'PluginAssembly',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    async createFlow(name, templateFlowId, options) {
+        return this.workflowManagement.createFlow(name, templateFlowId, options);
     }
     /**
-     * Delete a plugin assembly and all its associated components
-     * Used for rollback on deployment failure
-     * @param assemblyId - Assembly GUID to delete
+     * Delete a Power Automate flow (permanent operation)
      */
-    async deletePluginAssembly(assemblyId) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Note: Dataverse cascade deletes associated plugin types, steps, and images
-            await this.makeRequest(`api/data/v9.2/pluginassemblies(${assemblyId})`, 'DELETE');
-            auditLogger.log({
-                operation: 'delete-plugin-assembly',
-                operationType: 'DELETE',
-                componentId: assemblyId,
-                componentType: 'PluginAssembly',
-                success: true,
-                executionTimeMs: timer(),
-            });
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'delete-plugin-assembly',
-                operationType: 'DELETE',
-                componentId: assemblyId,
-                componentType: 'PluginAssembly',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw new Error(`Failed to delete plugin assembly: ${error.message}`);
-        }
+    async deleteFlow(flowId) {
+        return this.workflowManagement.deleteFlow(flowId);
     }
     /**
-     * Delete a plugin step
-     * Used for rollback on deployment failure
-     * @param stepId - Step GUID to delete
+     * Clone an existing flow with a new name
      */
-    async deletePluginStep(stepId) {
-        const timer = auditLogger.startTimer();
-        try {
-            await this.makeRequest(`api/data/v9.2/sdkmessageprocessingsteps(${stepId})`, 'DELETE');
-            auditLogger.log({
-                operation: 'delete-plugin-step',
-                operationType: 'DELETE',
-                componentId: stepId,
-                componentType: 'PluginStep',
-                success: true,
-                executionTimeMs: timer(),
-            });
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'delete-plugin-step',
-                operationType: 'DELETE',
-                componentId: stepId,
-                componentType: 'PluginStep',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            // Log but don't throw - rollback should continue even if individual deletes fail
-            console.error(`Warning: Failed to delete plugin step ${stepId}: ${error.message}`);
-        }
+    async cloneFlow(sourceFlowId, newName, options) {
+        return this.workflowManagement.cloneFlow(sourceFlowId, newName, options);
     }
     /**
-     * Register a plugin step on an SDK message
-     * @param options - Step registration options
-     * @returns Created step ID
+     * Activate a Power Automate flow (alias for activateWorkflow)
      */
-    async registerPluginStep(options) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Resolve SDK message and filter IDs
-            const { messageId, filterId } = await this.resolveSdkMessageAndFilter(options.messageName, options.primaryEntityName);
-            // Create step payload
-            const stepData = {
-                name: options.name,
-                'plugintypeid@odata.bind': `/plugintypes(${options.pluginTypeId})`,
-                'sdkmessageid@odata.bind': `/sdkmessages(${messageId})`,
-                'sdkmessagefilterid@odata.bind': `/sdkmessagefilters(${filterId})`,
-                stage: options.stage,
-                mode: options.executionMode,
-                rank: options.rank ?? 1,
-                supporteddeployment: options.supportedDeployment ?? 0,
-                statuscode: 1 // Active
-            };
-            // Add optional fields
-            if (options.filteringAttributes) {
-                stepData.filteringattributes = options.filteringAttributes;
-            }
-            if (options.configuration) {
-                stepData.configuration = options.configuration;
-            }
-            // Register step
-            const createResponse = await this.makeRequest('api/data/v9.2/sdkmessageprocessingsteps', 'POST', stepData, { 'Prefer': 'return=representation' });
-            const stepId = createResponse.sdkmessageprocessingstepid || createResponse.id;
-            if (!stepId) {
-                throw new Error('Plugin step created but ID not returned');
-            }
-            // Add to solution if specified
-            if (options.solutionUniqueName) {
-                await this.addComponentToSolution(options.solutionUniqueName, stepId, 92 // Component type 92 = SDKMessageProcessingStep
-                );
-            }
-            auditLogger.log({
-                operation: 'register-plugin-step',
-                operationType: 'CREATE',
-                componentId: stepId,
-                componentType: 'PluginStep',
-                success: true,
-                parameters: {
-                    name: options.name,
-                    messageName: options.messageName,
-                    primaryEntity: options.primaryEntityName,
-                    stage: options.stage,
-                    mode: options.executionMode
-                },
-                executionTimeMs: timer(),
-            });
-            return { stepId };
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'register-plugin-step',
-                operationType: 'CREATE',
-                componentName: options.name,
-                componentType: 'PluginStep',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    async activateFlow(flowId) {
+        return this.activateWorkflow(flowId);
     }
     /**
-     * Register a pre/post image for a plugin step
-     * @param options - Image registration options
-     * @returns Created image ID
+     * Deactivate a Power Automate flow (alias for deactivateWorkflow)
      */
-    async registerPluginImage(options) {
-        const timer = auditLogger.startTimer();
-        try {
-            // Create image payload
-            const imageData = {
-                name: options.name,
-                'sdkmessageprocessingstepid@odata.bind': `/sdkmessageprocessingsteps(${options.stepId})`,
-                imagetype: options.imageType,
-                entityalias: options.entityAlias,
-                messagepropertyname: options.messagePropertyName || 'Target'
-            };
-            // Add attributes if specified (empty string = all attributes)
-            if (options.attributes !== undefined) {
-                imageData.attributes = options.attributes;
-            }
-            // Register image
-            const createResponse = await this.makeRequest('api/data/v9.2/sdkmessageprocessingstepimages', 'POST', imageData, { 'Prefer': 'return=representation' });
-            const imageId = createResponse.sdkmessageprocessingstepimageid || createResponse.id;
-            if (!imageId) {
-                throw new Error('Plugin image created but ID not returned');
-            }
-            auditLogger.log({
-                operation: 'register-plugin-image',
-                operationType: 'CREATE',
-                componentId: imageId,
-                componentType: 'PluginImage',
-                success: true,
-                parameters: {
-                    name: options.name,
-                    imageType: options.imageType,
-                    stepId: options.stepId
-                },
-                executionTimeMs: timer(),
-            });
-            return { imageId };
-        }
-        catch (error) {
-            auditLogger.log({
-                operation: 'register-plugin-image',
-                operationType: 'CREATE',
-                componentName: options.name,
-                componentType: 'PluginImage',
-                success: false,
-                error: error.message,
-                executionTimeMs: timer(),
-            });
-            throw error;
-        }
+    async deactivateFlow(flowId) {
+        return this.deactivateWorkflow(flowId);
     }
 }
 //# sourceMappingURL=PowerPlatformService.js.map