@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/package/PackageBuilder.js

@@ -0,0 +1,386 @@
+"use strict";
+/**
+ * PackageBuilder - Fluent API for package operations with Promise chaining
+ *
+ * Supports:
+ * - Method chaining: builder.validate().then(b => b.create()).then(b => b.check())...
+ * - Error handling: .catch() for error callbacks
+ * - Cleanup: .finally() for guaranteed execution
+ * - Result storage: all results stored in logger/state
+ * - Chain interruption: chain stops on first error (standard Promise behavior)
+ *
+ * Available operations: validate, create, read, check, lock, unlock, update
+ *
+ * @example
+ * ```typescript
+ * const builder = new PackageBuilder(connection, logger, {
+ *   packageName: 'Z_TEST_PKG',
+ *   superPackage: 'ZOK_TEST_PKG_01'
+ * });
+ *
+ * await builder
+ *   .validate()
+ *   .then(b => b.create())
+ *   .then(b => b.check())
+ *   .catch(error => {
+ *     logger.error('Operation failed:', error);
+ *   });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBuilder = void 0;
+const create_1 = require("./create");
+const validation_1 = require("./validation");
+const check_1 = require("./check");
+const read_1 = require("./read");
+const lock_1 = require("./lock");
+const unlock_1 = require("./unlock");
+const update_1 = require("./update");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+class PackageBuilder {
+    connection;
+    logger;
+    config;
+    state;
+    constructor(connection, logger, config) {
+        this.connection = connection;
+        this.logger = logger;
+        this.config = { ...config };
+        this.state = {
+            errors: [],
+            sessionId: config.sessionId || (0, sessionUtils_1.generateSessionId)()
+        };
+    }
+    // Builder methods - return this for chaining
+    setSuperPackage(superPackage) {
+        this.config.superPackage = superPackage;
+        this.logger.debug?.('Super package set:', superPackage);
+        return this;
+    }
+    setDescription(description) {
+        this.config.description = description;
+        this.logger.debug?.('Description set:', description);
+        return this;
+    }
+    setPackageType(packageType) {
+        this.config.packageType = packageType;
+        this.logger.debug?.('Package type set:', packageType);
+        return this;
+    }
+    setSoftwareComponent(softwareComponent) {
+        this.config.softwareComponent = softwareComponent;
+        this.logger.debug?.('Software component set:', softwareComponent);
+        return this;
+    }
+    setTransportLayer(transportLayer) {
+        this.config.transportLayer = transportLayer;
+        this.logger.debug?.('Transport layer set:', transportLayer);
+        return this;
+    }
+    setRequest(transportRequest) {
+        this.config.transportRequest = transportRequest;
+        this.logger.debug?.('Transport request set:', transportRequest);
+        return this;
+    }
+    setApplicationComponent(applicationComponent) {
+        this.config.applicationComponent = applicationComponent;
+        this.logger.debug?.('Application component set:', applicationComponent);
+        return this;
+    }
+    setResponsible(responsible) {
+        this.config.responsible = responsible;
+        this.logger.debug?.('Responsible set:', responsible);
+        return this;
+    }
+    // Operation methods - return Promise<this> for Promise chaining
+    async validate() {
+        try {
+            this.logger.info?.('Validating package:', this.config.packageName);
+            const params = {
+                package_name: this.config.packageName,
+                super_package: this.config.superPackage,
+                description: this.config.description,
+                package_type: this.config.packageType,
+                software_component: this.config.softwareComponent,
+                transport_layer: this.config.transportLayer,
+                transport_request: this.config.transportRequest,
+                application_component: this.config.applicationComponent,
+                responsible: this.config.responsible
+            };
+            // Basic validation
+            try {
+                await (0, validation_1.validatePackageBasic)(this.connection, params);
+                this.state.validationResult = { basic: undefined };
+                this.logger.info?.('Package basic validation successful');
+            }
+            catch (validationError) {
+                // If package already exists, log warning but continue (cleanup may have failed)
+                const errorMsg = validationError.message || '';
+                if (errorMsg.includes('already exists') || errorMsg.includes('PAK042')) {
+                    this.logger.warn?.(`Package ${this.config.packageName} already exists. Validation skipped.`);
+                    this.state.validationResult = { basic: undefined }; // Mark as successful to continue
+                }
+                else {
+                    throw validationError; // Re-throw other validation errors
+                }
+            }
+            // Full validation only if both transport layer and software component are explicitly provided
+            // SAP requires transport layer for full validation, so we skip it if not provided
+            if (this.config.transportLayer && this.config.softwareComponent) {
+                await (0, validation_1.validatePackageFull)(this.connection, params, this.config.softwareComponent, this.config.transportLayer);
+                this.state.validationResult.full = undefined;
+                this.logger.info?.('Package full validation successful');
+            }
+            else {
+                this.logger.info?.('Skipping full validation (transport layer or software component not provided)');
+            }
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'validate',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Validation failed:', error);
+            throw error;
+        }
+    }
+    async create() {
+        try {
+            if (!this.config.superPackage) {
+                throw new Error('Super package is required');
+            }
+            this.logger.info?.('Creating package:', this.config.packageName);
+            const params = {
+                package_name: this.config.packageName,
+                super_package: this.config.superPackage,
+                description: this.config.description,
+                package_type: this.config.packageType,
+                software_component: this.config.softwareComponent,
+                transport_layer: this.config.transportLayer,
+                transport_request: this.config.transportRequest,
+                application_component: this.config.applicationComponent,
+                responsible: this.config.responsible
+            };
+            const result = await (0, create_1.createPackage)(this.connection, params);
+            this.state.createResult = result;
+            this.logger.info?.('Package created successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            const errorMsg = error.message || '';
+            // If package already exists, try to read it instead of failing
+            if (errorMsg.includes('already exists') || errorMsg.includes('PAK042')) {
+                this.logger.warn?.(`Package ${this.config.packageName} already exists. Attempting to read existing package.`);
+                try {
+                    const existingResult = await (0, read_1.getPackage)(this.connection, this.config.packageName);
+                    this.state.createResult = existingResult; // Store read result as create result
+                    this.logger.info?.('Package already exists, read successfully:', existingResult.status);
+                    return this;
+                }
+                catch (readError) {
+                    // If read also fails, throw original create error
+                    this.state.errors.push({
+                        method: 'create',
+                        error: error instanceof Error ? error : new Error(String(error)),
+                        timestamp: new Date()
+                    });
+                    this.logger.error?.('Create failed and read also failed:', error);
+                    throw error;
+                }
+            }
+            // For other errors, throw as usual
+            this.state.errors.push({
+                method: 'create',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Create failed:', error);
+            throw error;
+        }
+    }
+    async read() {
+        try {
+            this.logger.info?.('Reading package:', this.config.packageName);
+            const result = await (0, read_1.getPackage)(this.connection, this.config.packageName);
+            this.state.readResult = result;
+            this.logger.info?.('Package read successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'read',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Read failed:', error);
+            throw error;
+        }
+    }
+    async check() {
+        try {
+            this.logger.info?.('Checking package:', this.config.packageName);
+            await (0, check_1.checkPackage)(this.connection, this.config.packageName);
+            this.state.checkResult = undefined;
+            this.logger.info?.('Package check successful');
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'check',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Check failed:', error);
+            throw error;
+        }
+    }
+    async lock() {
+        try {
+            if (!this.state.sessionId) {
+                this.state.sessionId = (0, sessionUtils_1.generateSessionId)();
+            }
+            this.logger.info?.('Locking package:', this.config.packageName);
+            const lockHandle = await (0, lock_1.lockPackage)(this.connection, this.config.packageName, this.state.sessionId);
+            this.state.lockHandle = lockHandle;
+            this.state.lockResult = lockHandle;
+            // Register lock in persistent storage if callback provided
+            if (this.config.onLock) {
+                this.config.onLock(lockHandle, this.state.sessionId);
+            }
+            this.logger.info?.('Package locked successfully, lock handle:', lockHandle);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'lock',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Lock failed:', error);
+            throw error;
+        }
+    }
+    async unlock() {
+        try {
+            if (!this.state.sessionId) {
+                this.state.sessionId = (0, sessionUtils_1.generateSessionId)();
+            }
+            if (!this.state.lockHandle) {
+                throw new Error('Package must be locked before unlocking. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking package:', this.config.packageName);
+            const result = await (0, unlock_1.unlockPackage)(this.connection, this.config.packageName, this.state.lockHandle, this.state.sessionId);
+            this.state.unlockResult = result;
+            this.state.lockHandle = undefined;
+            this.logger.info?.('Package unlocked successfully');
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'unlock',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Unlock failed:', error);
+            throw error;
+        }
+    }
+    async update() {
+        try {
+            if (!this.state.sessionId) {
+                this.state.sessionId = (0, sessionUtils_1.generateSessionId)();
+            }
+            if (!this.state.lockHandle) {
+                throw new Error('Package must be locked before updating. Call lock() first.');
+            }
+            const descriptionToUpdate = this.config.updatedDescription || this.config.description;
+            if (!descriptionToUpdate) {
+                throw new Error('Description or updatedDescription is required for package update');
+            }
+            this.logger.info?.('Updating package description:', this.config.packageName);
+            const result = await (0, update_1.updatePackageDescription)(this.connection, this.config.packageName, descriptionToUpdate, this.state.lockHandle, this.state.sessionId);
+            this.state.updateResult = result;
+            this.logger.info?.('Package description updated successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'update',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Update failed:', error);
+            throw error;
+        }
+    }
+    async forceUnlock() {
+        if (!this.state.lockHandle) {
+            return;
+        }
+        if (!this.state.sessionId) {
+            this.state.sessionId = (0, sessionUtils_1.generateSessionId)();
+        }
+        try {
+            await (0, unlock_1.unlockPackage)(this.connection, this.config.packageName, this.state.lockHandle, this.state.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.packageName);
+        }
+        catch (error) {
+            this.logger.warn?.('Force unlock failed:', error);
+        }
+        finally {
+            this.state.lockHandle = undefined;
+        }
+    }
+    // Getters for accessing results
+    getState() {
+        return { ...this.state };
+    }
+    getPackageName() {
+        return this.config.packageName;
+    }
+    getValidationResult() {
+        return this.state.validationResult;
+    }
+    getCreateResult() {
+        return this.state.createResult;
+    }
+    getReadResult() {
+        return this.state.readResult;
+    }
+    getCheckResult() {
+        return this.state.checkResult;
+    }
+    getErrors() {
+        return [...this.state.errors];
+    }
+    getSessionId() {
+        return this.state.sessionId;
+    }
+    getLockHandle() {
+        return this.state.lockHandle;
+    }
+    getLockResult() {
+        return this.state.lockResult;
+    }
+    getUnlockResult() {
+        return this.state.unlockResult;
+    }
+    getUpdateResult() {
+        return this.state.updateResult;
+    }
+    getResults() {
+        return {
+            validate: this.state.validationResult,
+            create: this.state.createResult,
+            read: this.state.readResult,
+            check: this.state.checkResult,
+            lock: this.state.lockResult,
+            unlock: this.state.unlockResult,
+            update: this.state.updateResult,
+            errors: [...this.state.errors]
+        };
+    }
+}
+exports.PackageBuilder = PackageBuilder;

package/dist/core/package/check.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Package check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+/**
+ * Check package for errors
+ */
+export declare function checkPackage(connection: AbapConnection, packageName: string): Promise<void>;
+//# sourceMappingURL=check.d.ts.map

package/dist/core/package/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/package/check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAc,MAAM,0BAA0B,CAAC;AAGtE;;GAEG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,cAAc,EAC1B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/core/package/check.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Package check operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPackage = checkPackage;
+const connection_1 = require("@mcp-abap-adt/connection");
+/**
+ * Check package for errors
+ */
+async function checkPackage(connection, packageName) {
+    const baseUrl = await connection.getBaseUrl();
+    const url = `${baseUrl}/sap/bc/adt/checkruns`;
+    const xmlBody = `<?xml version="1.0" encoding="UTF-8"?><chkrun:checkObjectList xmlns:chkrun="http://www.sap.com/adt/checkrun" xmlns:adtcore="http://www.sap.com/adt/core">
+
+  <chkrun:checkObject adtcore:uri="/sap/bc/adt/packages/${packageName.toLowerCase()}" chkrun:version="active"/>
+
+</chkrun:checkObjectList>`;
+    await connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: (0, connection_1.getTimeout)('default'),
+        data: xmlBody,
+        headers: {
+            'Accept': 'application/vnd.sap.adt.checkmessages+xml',
+            'Content-Type': 'application/vnd.sap.adt.checkobjects+xml'
+        }
+    });
+}

package/dist/core/package/create.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Package create operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { CreatePackageParams } from './types';
+/**
+ * Create ABAP package
+ * Full workflow: validate basic -> check transport -> validate full -> create -> check
+ */
+export declare function createPackage(connection: AbapConnection, params: CreatePackageParams): Promise<AxiosResponse>;
+//# sourceMappingURL=create.d.ts.map

package/dist/core/package/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/core/package/create.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAc,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAKtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AA6G9C;;;GAGG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,aAAa,CAAC,CAwDxB"}

package/dist/core/package/create.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Package create operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackage = createPackage;
+const connection_1 = require("@mcp-abap-adt/connection");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const validation_1 = require("./validation");
+const transportCheck_1 = require("./transportCheck");
+const check_1 = require("./check");
+const systemInfo_1 = require("../shared/systemInfo");
+/**
+ * Step 4: Create package
+ * Only allowed parameters: name, description, superPackage, packageType, softwareComponent, transportLayer
+ * masterSystem/responsible are derived via getSystemInformation (cloud) or env fallbacks
+ */
+async function createPackageInternal(connection, args, swcomp, transportLayer, transportRequest) {
+    const baseUrl = await connection.getBaseUrl();
+    const url = `${baseUrl}/sap/bc/adt/packages`;
+    // Escape XML special characters in description
+    const escapeXml = (str) => {
+        if (!str)
+            return '';
+        return str
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    };
+    const description = escapeXml(args.description || args.package_name);
+    const packageType = args.package_type || 'development';
+    // Get master system / responsible from ADT metadata helper (cloud) with env fallback
+    const systemInfo = await (0, systemInfo_1.getSystemInformation)(connection);
+    const masterSystem = systemInfo?.systemID;
+    const responsibleUser = args.responsible ||
+        systemInfo?.userName ||
+        process.env.SAP_USERNAME ||
+        process.env.SAP_USER ||
+        '';
+    // All attributes must be present in XML body, even if empty
+    // Software component - always include, with name attribute if provided
+    const softwareComponentXml = swcomp
+        ? `<pak:softwareComponent pak:name="${escapeXml(swcomp)}"/>`
+        : '<pak:softwareComponent/>';
+    // Transport layer - always include, with name attribute if provided
+    const transportLayerXml = transportLayer
+        ? `<pak:transportLayer pak:name="${escapeXml(transportLayer)}"/>`
+        : '<pak:transportLayer/>';
+    // Build XML with all required attributes
+    const responsibleAttr = responsibleUser ? ` adtcore:responsible="${escapeXml(responsibleUser)}"` : '';
+    const masterSystemAttr = masterSystem ? ` adtcore:masterSystem="${escapeXml(masterSystem)}"` : '';
+    // Application component - always include, with name attribute if provided
+    const applicationComponentXml = args.application_component
+        ? `<pak:applicationComponent pak:name="${escapeXml(args.application_component)}"/>`
+        : '<pak:applicationComponent/>';
+    const xmlBody = `<?xml version="1.0" encoding="UTF-8"?><pak:package xmlns:pak="http://www.sap.com/adt/packages" xmlns:adtcore="http://www.sap.com/adt/core" adtcore:description="${description}" adtcore:language="EN" adtcore:name="${args.package_name}" adtcore:type="DEVC/K" adtcore:masterLanguage="EN"${masterSystemAttr}${responsibleAttr}>
+
+  <adtcore:packageRef adtcore:name="${args.package_name}"/>
+
+  <pak:attributes pak:isEncapsulated="false" pak:packageType="${packageType}" pak:recordChanges="false"/>
+
+  <pak:superPackage adtcore:name="${args.super_package}"/>
+
+  ${applicationComponentXml}
+
+  <pak:transport>
+
+    ${softwareComponentXml}
+
+    ${transportLayerXml}
+
+  </pak:transport>
+
+  <pak:translation/>
+
+  <pak:useAccesses/>
+
+  <pak:packageInterfaces/>
+
+  <pak:subPackages/>
+
+</pak:package>`;
+    const queryParams = transportRequest ? { corrNr: transportRequest } : undefined;
+    const response = await connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: (0, connection_1.getTimeout)('default'),
+        data: xmlBody,
+        params: queryParams,
+        headers: {
+            'Accept': 'application/vnd.sap.adt.packages.v2+xml, application/vnd.sap.adt.packages.v1+xml',
+            'Content-Type': 'application/vnd.sap.adt.packages.v2+xml'
+        }
+    });
+    const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false, attributeNamePrefix: '' });
+    const result = parser.parse(response.data);
+    return result['pak:package'];
+}
+/**
+ * Create ABAP package
+ * Full workflow: validate basic -> check transport -> validate full -> create -> check
+ */
+async function createPackage(connection, params) {
+    if (!params.package_name) {
+        throw new Error('Package name is required');
+    }
+    if (!params.super_package) {
+        throw new Error('Super package (parent package) is required');
+    }
+    // software_component and transport_layer can be empty/undefined
+    const swcomp = params.software_component;
+    const transportLayer = params.transport_layer;
+    try {
+        await (0, validation_1.validatePackageBasic)(connection, params);
+        let transportRequest = params.transport_request;
+        if (transportLayer && !transportRequest) {
+            const availableTransports = await (0, transportCheck_1.checkTransportRequirements)(connection, params, transportLayer);
+            if (availableTransports.length > 0) {
+                transportRequest = availableTransports[0];
+            }
+        }
+        if (transportLayer && !transportRequest) {
+            throw new Error('Transport request is required when transport_layer is specified. Please provide transport_request parameter or create a transport first.');
+        }
+        // Full validation only if both swcomp and transportLayer are provided
+        // Otherwise SAP will complain about missing transport layer
+        if (swcomp && transportLayer) {
+            await (0, validation_1.validatePackageFull)(connection, params, swcomp, transportLayer);
+        }
+        // In XML body, all attributes must be present (even if empty)
+        // Pass empty strings to createPackageInternal so XML includes all elements
+        const createResponse = await createPackageInternal(connection, params, swcomp || '', transportLayer || '', transportRequest);
+        await (0, check_1.checkPackage)(connection, params.package_name);
+        // Return the real response from SAP (from initial POST)
+        return createResponse;
+    }
+    catch (error) {
+        const errorMessage = error.response?.data
+            ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+            : error.message;
+        throw new Error(`Failed to create package ${params.package_name}: ${errorMessage}`);
+    }
+}

package/dist/core/package/delete.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Package delete operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+export interface DeletePackageParams {
+    package_name: string;
+    transport_request?: string;
+}
+/**
+ * Check if package can be deleted (deletion check)
+ * Returns response with isDeletable flag
+ */
+export declare function checkPackageDeletion(connection: AbapConnection, params: DeletePackageParams): Promise<AxiosResponse>;
+/**
+ * Parse deletion check response to get isDeletable flag
+ */
+export declare function parsePackageDeletionCheck(response: AxiosResponse): {
+    isDeletable: boolean;
+    message?: string;
+};
+/**
+ * Delete ABAP package using ADT deletion API
+ * For packages, empty transportNumber tag may be required
+ */
+export declare function deletePackage(connection: AbapConnection, params: DeletePackageParams): Promise<AxiosResponse>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/core/package/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/core/package/delete.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAc,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAItC,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,aAAa,CAAC,CA6BxB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,aAAa,GAAG;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAqB7G;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,aAAa,CAAC,CA+ExB"}