@siliconst/metaui 1.4.17 → 1.4.21

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin.d.ts

@@ -0,0 +1,23 @@
+declare module "nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin" {
+    /**
+     * @file IHeuristicPlugin.ts
+     * @description Contract for plugins that inspect and mutate the raw OpenAPI AST before translation.
+     */
+    /**
+     * Interface defining the operational boundaries for structural heuristic plugins.
+     * Implementations are executed synchronously during the pre-processing phase to normalize
+     * non-standard schema constructs (like generic object unions) before translation occurs.
+     *
+     * @public
+     */
+    export interface IHeuristicPlugin {
+        /**
+         * Evaluates and mutates the provided OpenAPI AST in-place.
+         * Heuristics are expected to strictly scope their mutations to patterns they explicitly recognize.
+         *
+         * @param {any} openApiRoot The mutable OpenAPI root document block.
+         */
+        apply(openApiRoot: unknown): void;
+    }
+}
+//# sourceMappingURL=IHeuristicPlugin.d.ts.map

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IHeuristicPlugin.d.ts","sourceRoot":"../../../../../../../../../..","sources":["src/nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,2EAA2E,CAAC;IAC3F;;;OAGG;IAEH;;;;;;OAMG;IACH,UAAiB,gBAAgB;QAC7B;;;;;WAKG;QACH,KAAK,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAAC;KACrC;CAEA"}

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IHeuristicPlugin.js.map

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IHeuristicPlugin.js","names":[],"sources":[],"mappings":"","ignoreList":[]}

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin.ts

@@ -0,0 +1,21 @@
+/**
+ * @file IHeuristicPlugin.ts
+ * @description Contract for plugins that inspect and mutate the raw OpenAPI AST before translation.
+ */
+
+/**
+ * Interface defining the operational boundaries for structural heuristic plugins.
+ * Implementations are executed synchronously during the pre-processing phase to normalize
+ * non-standard schema constructs (like generic object unions) before translation occurs.
+ * 
+ * @public
+ */
+export interface IHeuristicPlugin {
+    /**
+     * Evaluates and mutates the provided OpenAPI AST in-place.
+     * Heuristics are expected to strictly scope their mutations to patterns they explicitly recognize.
+     * 
+     * @param {any} openApiRoot The mutable OpenAPI root document block.
+     */
+    apply(openApiRoot: unknown): void;
+}

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic-dbg.js

@@ -0,0 +1,117 @@
+sap.ui.define([], function () {
+  "use strict";
+
+  /**
+   * @file ProtobufVariantHeuristic.ts
+   * @description Scans OpenAPI 2.0 schemas for implicitly polymorphic structures (e.g., objects containing purely optional, mutually exclusive fields) and explicitly mutates them into `oneOf` structures.
+   */
+
+  /**
+   * Heuristic plugin that detects Protobuf-style Variant representations (objects with exclusively optional *_value fields)
+   * and mutates the AST to a proper oneOf polymorphic array before it reaches the parsers.
+   * 
+   * @public
+   */
+  class ProtobufVariantHeuristic {
+    /**
+     * Executes the heuristic logic against the OpenAPI AST.
+     * Initiates a scan of the global definitions block if the document matches the OpenAPI 2.0 specification.
+     * 
+     * @param {any} openApiRoot The entire OpenAPI root document.
+     */
+    apply(openApiRoot) {
+      if (!openApiRoot) return;
+
+      // In OpenAPI 2.0, scan definitions
+      if (openApiRoot.swagger === "2.0" && openApiRoot.definitions) {
+        this._scanDefinitions(openApiRoot.definitions);
+      }
+    }
+
+    /**
+     * Iterates over all root-level definitions to detect and mutate variant structures.
+     * 
+     * @param {Record<string, any>} definitions The raw OpenAPI 2.0 definitions dictionary.
+     * @private
+     */
+    _scanDefinitions(definitions) {
+      for (const [key, definition] of Object.entries(definitions)) {
+        // Heuristic 1: If the object name ends with "Value" and has multiple optional properties 
+        // that end with "_value" (common Protobuf JSON representation for variants)
+        if (this._isProtobufVariant(key, definition)) {
+          this._mutateToOneOf(definition);
+        }
+      }
+    }
+
+    /**
+     * Evaluates a schema block against the heuristic signature of a Protobuf Variant.
+     * 
+     * @param {string} key The schema definition name.
+     * @param {any} definition The structural definition block.
+     * @returns {boolean} True if the structure matches a Protobuf variant pattern.
+     * @private
+     */
+    _isProtobufVariant(key, definition) {
+      if (definition.type !== "object" || !definition.properties) {
+        return false;
+      }
+
+      // Must not have required fields if it's a pure union
+      if (definition.required && definition.required.length > 0) {
+        return false;
+      }
+      const propKeys = Object.keys(definition.properties);
+      if (propKeys.length < 2) {
+        return false;
+      }
+
+      // Check if all properties end with "_value" (e.g. bool_value, list_value)
+      const allEndWithValue = propKeys.every(k => k.endsWith("_value"));
+      if (allEndWithValue && (key.endsWith("Value") || key.endsWith("Variant"))) {
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Mutates the AST in-place by synthesizing a `oneOf` array from the optional properties
+     * and strictly purging the original object layout to force polymorphic evaluation.
+     * 
+     * @param {any} definition The target variant object schema.
+     * @private
+     */
+    _mutateToOneOf(definition) {
+      const propKeys = Object.keys(definition.properties);
+      const oneOfArray = [];
+      for (const propKey of propKeys) {
+        const variantSchema = definition.properties[propKey];
+
+        // Reconstruct a sub-object for each variant, enforcing strict requirement of the single variant property
+        const syntheticVariant = {
+          type: "object",
+          properties: {
+            [propKey]: variantSchema
+          },
+          required: [propKey],
+          title: variantSchema.description || propKey
+        };
+        oneOfArray.push(syntheticVariant);
+      }
+
+      // Mutate the original definition to become a oneOf root
+      definition.oneOf = oneOfArray;
+
+      // CRITICAL DESTRUCTIVE MUTATION:
+      // We delete the original properties block. If this is not done, the core engine's layout
+      // orchestrator will attempt to render both a standard static form AND the polymorphic switcher simultaneously.
+      delete definition.properties;
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.ProtobufVariantHeuristic = ProtobufVariantHeuristic;
+  return __exports;
+});
+//# sourceMappingURL=ProtobufVariantHeuristic-dbg.js.map

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic-dbg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufVariantHeuristic-dbg.js","names":["ProtobufVariantHeuristic","apply","openApiRoot","swagger","definitions","_scanDefinitions","key","definition","Object","entries","_isProtobufVariant","_mutateToOneOf","type","properties","required","length","propKeys","keys","allEndWithValue","every","k","endsWith","oneOfArray","propKey","variantSchema","syntheticVariant","title","description","push","oneOf","__exports","__esModule"],"sources":["ProtobufVariantHeuristic.ts"],"sourcesContent":["/**\n * @file ProtobufVariantHeuristic.ts\n * @description Scans OpenAPI 2.0 schemas for implicitly polymorphic structures (e.g., objects containing purely optional, mutually exclusive fields) and explicitly mutates them into `oneOf` structures.\n */\n\nimport { IHeuristicPlugin } from \"../interfaces/IHeuristicPlugin\";\n\n/**\n * Heuristic plugin that detects Protobuf-style Variant representations (objects with exclusively optional *_value fields)\n * and mutates the AST to a proper oneOf polymorphic array before it reaches the parsers.\n * \n * @public\n */\nexport class ProtobufVariantHeuristic implements IHeuristicPlugin {\n    /**\n     * Executes the heuristic logic against the OpenAPI AST.\n     * Initiates a scan of the global definitions block if the document matches the OpenAPI 2.0 specification.\n     * \n     * @param {any} openApiRoot The entire OpenAPI root document.\n     */\n    public apply(openApiRoot: unknown): void {\n        if (!openApiRoot) return;\n\n        // In OpenAPI 2.0, scan definitions\n        if (openApiRoot.swagger === \"2.0\" && openApiRoot.definitions) {\n            this._scanDefinitions(openApiRoot.definitions);\n        }\n    }\n\n    /**\n     * Iterates over all root-level definitions to detect and mutate variant structures.\n     * \n     * @param {Record<string, any>} definitions The raw OpenAPI 2.0 definitions dictionary.\n     * @private\n     */\n    private _scanDefinitions(definitions: Record<string, any>): void {\n        for (const [key, definition] of Object.entries(definitions)) {\n            // Heuristic 1: If the object name ends with \"Value\" and has multiple optional properties \n            // that end with \"_value\" (common Protobuf JSON representation for variants)\n            if (this._isProtobufVariant(key, definition)) {\n                this._mutateToOneOf(definition);\n            }\n        }\n    }\n\n    /**\n     * Evaluates a schema block against the heuristic signature of a Protobuf Variant.\n     * \n     * @param {string} key The schema definition name.\n     * @param {any} definition The structural definition block.\n     * @returns {boolean} True if the structure matches a Protobuf variant pattern.\n     * @private\n     */\n    private _isProtobufVariant(key: string, definition: unknown): boolean {\n        if (definition.type !== \"object\" || !definition.properties) {\n            return false;\n        }\n\n        // Must not have required fields if it's a pure union\n        if (definition.required && definition.required.length > 0) {\n            return false;\n        }\n\n        const propKeys = Object.keys(definition.properties);\n        if (propKeys.length < 2) {\n            return false;\n        }\n\n        // Check if all properties end with \"_value\" (e.g. bool_value, list_value)\n        const allEndWithValue = propKeys.every(k => k.endsWith(\"_value\"));\n        if (allEndWithValue && (key.endsWith(\"Value\") || key.endsWith(\"Variant\"))) {\n            return true;\n        }\n\n        return false;\n    }\n\n    /**\n     * Mutates the AST in-place by synthesizing a `oneOf` array from the optional properties\n     * and strictly purging the original object layout to force polymorphic evaluation.\n     * \n     * @param {any} definition The target variant object schema.\n     * @private\n     */\n    private _mutateToOneOf(definition: unknown): void {\n        const propKeys = Object.keys(definition.properties);\n        const oneOfArray: unknown[] = [];\n\n        for (const propKey of propKeys) {\n            const variantSchema = definition.properties[propKey];\n            \n            // Reconstruct a sub-object for each variant, enforcing strict requirement of the single variant property\n            const syntheticVariant = {\n                type: \"object\",\n                properties: {\n                    [propKey]: variantSchema\n                },\n                required: [propKey],\n                title: variantSchema.description || propKey\n            };\n            \n            oneOfArray.push(syntheticVariant);\n        }\n\n        // Mutate the original definition to become a oneOf root\n        definition.oneOf = oneOfArray;\n        \n        // CRITICAL DESTRUCTIVE MUTATION:\n        // We delete the original properties block. If this is not done, the core engine's layout\n        // orchestrator will attempt to render both a standard static form AND the polymorphic switcher simultaneously.\n        delete definition.properties;\n    }\n}\n"],"mappings":";;;EAAA;AACA;AACA;AACA;;EAIA;AACA;AACA;AACA;AACA;AACA;EACO,MAAMA,wBAAwB,CAA6B;IAC9D;AACJ;AACA;AACA;AACA;AACA;IACWC,KAAKA,CAACC,WAAoB,EAAQ;MACrC,IAAI,CAACA,WAAW,EAAE;;MAElB;MACA,IAAIA,WAAW,CAACC,OAAO,KAAK,KAAK,IAAID,WAAW,CAACE,WAAW,EAAE;QAC1D,IAAI,CAACC,gBAAgB,CAACH,WAAW,CAACE,WAAW,CAAC;MAClD;IACJ;;IAEA;AACJ;AACA;AACA;AACA;AACA;IACYC,gBAAgBA,CAACD,WAAgC,EAAQ;MAC7D,KAAK,MAAM,CAACE,GAAG,EAAEC,UAAU,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACL,WAAW,CAAC,EAAE;QACzD;QACA;QACA,IAAI,IAAI,CAACM,kBAAkB,CAACJ,GAAG,EAAEC,UAAU,CAAC,EAAE;UAC1C,IAAI,CAACI,cAAc,CAACJ,UAAU,CAAC;QACnC;MACJ;IACJ;;IAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;IACYG,kBAAkBA,CAACJ,GAAW,EAAEC,UAAmB,EAAW;MAClE,IAAIA,UAAU,CAACK,IAAI,KAAK,QAAQ,IAAI,CAACL,UAAU,CAACM,UAAU,EAAE;QACxD,OAAO,KAAK;MAChB;;MAEA;MACA,IAAIN,UAAU,CAACO,QAAQ,IAAIP,UAAU,CAACO,QAAQ,CAACC,MAAM,GAAG,CAAC,EAAE;QACvD,OAAO,KAAK;MAChB;MAEA,MAAMC,QAAQ,GAAGR,MAAM,CAACS,IAAI,CAACV,UAAU,CAACM,UAAU,CAAC;MACnD,IAAIG,QAAQ,CAACD,MAAM,GAAG,CAAC,EAAE;QACrB,OAAO,KAAK;MAChB;;MAEA;MACA,MAAMG,eAAe,GAAGF,QAAQ,CAACG,KAAK,CAACC,CAAC,IAAIA,CAAC,CAACC,QAAQ,CAAC,QAAQ,CAAC,CAAC;MACjE,IAAIH,eAAe,KAAKZ,GAAG,CAACe,QAAQ,CAAC,OAAO,CAAC,IAAIf,GAAG,CAACe,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE;QACvE,OAAO,IAAI;MACf;MAEA,OAAO,KAAK;IAChB;;IAEA;AACJ;AACA;AACA;AACA;AACA;AACA;IACYV,cAAcA,CAACJ,UAAmB,EAAQ;MAC9C,MAAMS,QAAQ,GAAGR,MAAM,CAACS,IAAI,CAACV,UAAU,CAACM,UAAU,CAAC;MACnD,MAAMS,UAAqB,GAAG,EAAE;MAEhC,KAAK,MAAMC,OAAO,IAAIP,QAAQ,EAAE;QAC5B,MAAMQ,aAAa,GAAGjB,UAAU,CAACM,UAAU,CAACU,OAAO,CAAC;;QAEpD;QACA,MAAME,gBAAgB,GAAG;UACrBb,IAAI,EAAE,QAAQ;UACdC,UAAU,EAAE;YACR,CAACU,OAAO,GAAGC;UACf,CAAC;UACDV,QAAQ,EAAE,CAACS,OAAO,CAAC;UACnBG,KAAK,EAAEF,aAAa,CAACG,WAAW,IAAIJ;QACxC,CAAC;QAEDD,UAAU,CAACM,IAAI,CAACH,gBAAgB,CAAC;MACrC;;MAEA;MACAlB,UAAU,CAACsB,KAAK,GAAGP,UAAU;;MAE7B;MACA;MACA;MACA,OAAOf,UAAU,CAACM,UAAU;IAChC;EACJ;EAAC,IAAAiB,SAAA;IAAAC,UAAA;EAAA;EAAAD,SAAA,CAAA9B,wBAAA,GAAAA,wBAAA;EAAA,OAAA8B,SAAA;AAAA","ignoreList":[]}

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic.d.ts

@@ -0,0 +1,47 @@
+declare module "nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic" {
+    /**
+     * @file ProtobufVariantHeuristic.ts
+     * @description Scans OpenAPI 2.0 schemas for implicitly polymorphic structures (e.g., objects containing purely optional, mutually exclusive fields) and explicitly mutates them into `oneOf` structures.
+     */
+    import { IHeuristicPlugin } from "nz/co/siliconst/ui5/metaui/openapi/heuristics/interfaces/IHeuristicPlugin";
+    /**
+     * Heuristic plugin that detects Protobuf-style Variant representations (objects with exclusively optional *_value fields)
+     * and mutates the AST to a proper oneOf polymorphic array before it reaches the parsers.
+     *
+     * @public
+     */
+    export class ProtobufVariantHeuristic implements IHeuristicPlugin {
+        /**
+         * Executes the heuristic logic against the OpenAPI AST.
+         * Initiates a scan of the global definitions block if the document matches the OpenAPI 2.0 specification.
+         *
+         * @param {any} openApiRoot The entire OpenAPI root document.
+         */
+        apply(openApiRoot: unknown): void;
+        /**
+         * Iterates over all root-level definitions to detect and mutate variant structures.
+         *
+         * @param {Record<string, any>} definitions The raw OpenAPI 2.0 definitions dictionary.
+         * @private
+         */
+        private _scanDefinitions;
+        /**
+         * Evaluates a schema block against the heuristic signature of a Protobuf Variant.
+         *
+         * @param {string} key The schema definition name.
+         * @param {any} definition The structural definition block.
+         * @returns {boolean} True if the structure matches a Protobuf variant pattern.
+         * @private
+         */
+        private _isProtobufVariant;
+        /**
+         * Mutates the AST in-place by synthesizing a `oneOf` array from the optional properties
+         * and strictly purging the original object layout to force polymorphic evaluation.
+         *
+         * @param {any} definition The target variant object schema.
+         * @private
+         */
+        private _mutateToOneOf;
+    }
+}
+//# sourceMappingURL=ProtobufVariantHeuristic.d.ts.map

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufVariantHeuristic.d.ts","sourceRoot":"../../../../../../../../../..","sources":["src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,gFAAgF,CAAC;IAChG;;;OAGG;IAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,2EAA2E,CAAC;IAE7G;;;;;OAKG;IACH,MAAa,wBAAyB,YAAW,gBAAgB;QAC7D;;;;;WAKG;QACI,KAAK,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI;QASxC;;;;;WAKG;QACH,OAAO,CAAC,gBAAgB;QAUxB;;;;;;;WAOG;QACH,OAAO,CAAC,kBAAkB;QAwB1B;;;;;;WAMG;QACH,OAAO,CAAC,cAAc;KA4BzB;CAEA"}

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic.js

@@ -0,0 +1,2 @@
+sap.ui.define([],function(){"use strict";class e{apply(e){if(!e)return;if(e.swagger==="2.0"&&e.definitions){this._scanDefinitions(e.definitions)}}_scanDefinitions(e){for(const[t,i]of Object.entries(e)){if(this._isProtobufVariant(t,i)){this._mutateToOneOf(i)}}}_isProtobufVariant(e,t){if(t.type!=="object"||!t.properties){return false}if(t.required&&t.required.length>0){return false}const i=Object.keys(t.properties);if(i.length<2){return false}const r=i.every(e=>e.endsWith("_value"));if(r&&(e.endsWith("Value")||e.endsWith("Variant"))){return true}return false}_mutateToOneOf(e){const t=Object.keys(e.properties);const i=[];for(const r of t){const t=e.properties[r];const s={type:"object",properties:{[r]:t},required:[r],title:t.description||r};i.push(s)}e.oneOf=i;delete e.properties}}var t={__esModule:true};t.ProtobufVariantHeuristic=e;return t});
+//# sourceMappingURL=ProtobufVariantHeuristic.js.map

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufVariantHeuristic.js","names":["ProtobufVariantHeuristic","apply","openApiRoot","swagger","definitions","this","_scanDefinitions","key","definition","Object","entries","_isProtobufVariant","_mutateToOneOf","type","properties","required","length","propKeys","keys","allEndWithValue","every","k","endsWith","oneOfArray","propKey","variantSchema","syntheticVariant","title","description","push","oneOf","__exports","__esModule"],"sources":["ProtobufVariantHeuristic.ts"],"sourcesContent":["/**\n * @file ProtobufVariantHeuristic.ts\n * @description Scans OpenAPI 2.0 schemas for implicitly polymorphic structures (e.g., objects containing purely optional, mutually exclusive fields) and explicitly mutates them into `oneOf` structures.\n */\n\nimport { IHeuristicPlugin } from \"../interfaces/IHeuristicPlugin\";\n\n/**\n * Heuristic plugin that detects Protobuf-style Variant representations (objects with exclusively optional *_value fields)\n * and mutates the AST to a proper oneOf polymorphic array before it reaches the parsers.\n * \n * @public\n */\nexport class ProtobufVariantHeuristic implements IHeuristicPlugin {\n    /**\n     * Executes the heuristic logic against the OpenAPI AST.\n     * Initiates a scan of the global definitions block if the document matches the OpenAPI 2.0 specification.\n     * \n     * @param {any} openApiRoot The entire OpenAPI root document.\n     */\n    public apply(openApiRoot: unknown): void {\n        if (!openApiRoot) return;\n\n        // In OpenAPI 2.0, scan definitions\n        if (openApiRoot.swagger === \"2.0\" && openApiRoot.definitions) {\n            this._scanDefinitions(openApiRoot.definitions);\n        }\n    }\n\n    /**\n     * Iterates over all root-level definitions to detect and mutate variant structures.\n     * \n     * @param {Record<string, any>} definitions The raw OpenAPI 2.0 definitions dictionary.\n     * @private\n     */\n    private _scanDefinitions(definitions: Record<string, any>): void {\n        for (const [key, definition] of Object.entries(definitions)) {\n            // Heuristic 1: If the object name ends with \"Value\" and has multiple optional properties \n            // that end with \"_value\" (common Protobuf JSON representation for variants)\n            if (this._isProtobufVariant(key, definition)) {\n                this._mutateToOneOf(definition);\n            }\n        }\n    }\n\n    /**\n     * Evaluates a schema block against the heuristic signature of a Protobuf Variant.\n     * \n     * @param {string} key The schema definition name.\n     * @param {any} definition The structural definition block.\n     * @returns {boolean} True if the structure matches a Protobuf variant pattern.\n     * @private\n     */\n    private _isProtobufVariant(key: string, definition: unknown): boolean {\n        if (definition.type !== \"object\" || !definition.properties) {\n            return false;\n        }\n\n        // Must not have required fields if it's a pure union\n        if (definition.required && definition.required.length > 0) {\n            return false;\n        }\n\n        const propKeys = Object.keys(definition.properties);\n        if (propKeys.length < 2) {\n            return false;\n        }\n\n        // Check if all properties end with \"_value\" (e.g. bool_value, list_value)\n        const allEndWithValue = propKeys.every(k => k.endsWith(\"_value\"));\n        if (allEndWithValue && (key.endsWith(\"Value\") || key.endsWith(\"Variant\"))) {\n            return true;\n        }\n\n        return false;\n    }\n\n    /**\n     * Mutates the AST in-place by synthesizing a `oneOf` array from the optional properties\n     * and strictly purging the original object layout to force polymorphic evaluation.\n     * \n     * @param {any} definition The target variant object schema.\n     * @private\n     */\n    private _mutateToOneOf(definition: unknown): void {\n        const propKeys = Object.keys(definition.properties);\n        const oneOfArray: unknown[] = [];\n\n        for (const propKey of propKeys) {\n            const variantSchema = definition.properties[propKey];\n            \n            // Reconstruct a sub-object for each variant, enforcing strict requirement of the single variant property\n            const syntheticVariant = {\n                type: \"object\",\n                properties: {\n                    [propKey]: variantSchema\n                },\n                required: [propKey],\n                title: variantSchema.description || propKey\n            };\n            \n            oneOfArray.push(syntheticVariant);\n        }\n\n        // Mutate the original definition to become a oneOf root\n        definition.oneOf = oneOfArray;\n        \n        // CRITICAL DESTRUCTIVE MUTATION:\n        // We delete the original properties block. If this is not done, the core engine's layout\n        // orchestrator will attempt to render both a standard static form AND the polymorphic switcher simultaneously.\n        delete definition.properties;\n    }\n}\n"],"mappings":"yCAaO,MAAMA,EAOFC,MAAMC,GACT,IAAKA,EAAa,OAGlB,GAAIA,EAAYC,UAAY,OAASD,EAAYE,YAAa,CAC1DC,KAAKC,iBAAiBJ,EAAYE,YACtC,CACJ,CAQQE,iBAAiBF,GACrB,IAAK,MAAOG,EAAKC,KAAeC,OAAOC,QAAQN,GAAc,CAGzD,GAAIC,KAAKM,mBAAmBJ,EAAKC,GAAa,CAC1CH,KAAKO,eAAeJ,EACxB,CACJ,CACJ,CAUQG,mBAAmBJ,EAAaC,GACpC,GAAIA,EAAWK,OAAS,WAAaL,EAAWM,WAAY,CACxD,OAAO,KACX,CAGA,GAAIN,EAAWO,UAAYP,EAAWO,SAASC,OAAS,EAAG,CACvD,OAAO,KACX,CAEA,MAAMC,EAAWR,OAAOS,KAAKV,EAAWM,YACxC,GAAIG,EAASD,OAAS,EAAG,CACrB,OAAO,KACX,CAGA,MAAMG,EAAkBF,EAASG,MAAMC,GAAKA,EAAEC,SAAS,WACvD,GAAIH,IAAoBZ,EAAIe,SAAS,UAAYf,EAAIe,SAAS,YAAa,CACvE,OAAO,IACX,CAEA,OAAO,KACX,CASQV,eAAeJ,GACnB,MAAMS,EAAWR,OAAOS,KAAKV,EAAWM,YACxC,MAAMS,EAAwB,GAE9B,IAAK,MAAMC,KAAWP,EAAU,CAC5B,MAAMQ,EAAgBjB,EAAWM,WAAWU,GAG5C,MAAME,EAAmB,CACrBb,KAAM,SACNC,WAAY,CACRU,CAACA,GAAUC,GAEfV,SAAU,CAACS,GACXG,MAAOF,EAAcG,aAAeJ,GAGxCD,EAAWM,KAAKH,EACpB,CAGAlB,EAAWsB,MAAQP,SAKZf,EAAWM,UACtB,EACH,IAAAiB,EAAA,CAAAC,WAAA,MAAAD,EAAA/B,2BAAA,OAAA+B,CAAA","ignoreList":[]}

package/src/nz/co/siliconst/ui5/metaui/openapi/heuristics/plugins/ProtobufVariantHeuristic.ts

@@ -0,0 +1,113 @@
+/**
+ * @file ProtobufVariantHeuristic.ts
+ * @description Scans OpenAPI 2.0 schemas for implicitly polymorphic structures (e.g., objects containing purely optional, mutually exclusive fields) and explicitly mutates them into `oneOf` structures.
+ */
+
+import { IHeuristicPlugin } from "../interfaces/IHeuristicPlugin";
+
+/**
+ * Heuristic plugin that detects Protobuf-style Variant representations (objects with exclusively optional *_value fields)
+ * and mutates the AST to a proper oneOf polymorphic array before it reaches the parsers.
+ * 
+ * @public
+ */
+export class ProtobufVariantHeuristic implements IHeuristicPlugin {
+    /**
+     * Executes the heuristic logic against the OpenAPI AST.
+     * Initiates a scan of the global definitions block if the document matches the OpenAPI 2.0 specification.
+     * 
+     * @param {any} openApiRoot The entire OpenAPI root document.
+     */
+    public apply(openApiRoot: unknown): void {
+        if (!openApiRoot) return;
+
+        // In OpenAPI 2.0, scan definitions
+        if (openApiRoot.swagger === "2.0" && openApiRoot.definitions) {
+            this._scanDefinitions(openApiRoot.definitions);
+        }
+    }
+
+    /**
+     * Iterates over all root-level definitions to detect and mutate variant structures.
+     * 
+     * @param {Record<string, any>} definitions The raw OpenAPI 2.0 definitions dictionary.
+     * @private
+     */
+    private _scanDefinitions(definitions: Record<string, any>): void {
+        for (const [key, definition] of Object.entries(definitions)) {
+            // Heuristic 1: If the object name ends with "Value" and has multiple optional properties 
+            // that end with "_value" (common Protobuf JSON representation for variants)
+            if (this._isProtobufVariant(key, definition)) {
+                this._mutateToOneOf(definition);
+            }
+        }
+    }
+
+    /**
+     * Evaluates a schema block against the heuristic signature of a Protobuf Variant.
+     * 
+     * @param {string} key The schema definition name.
+     * @param {any} definition The structural definition block.
+     * @returns {boolean} True if the structure matches a Protobuf variant pattern.
+     * @private
+     */
+    private _isProtobufVariant(key: string, definition: unknown): boolean {
+        if (definition.type !== "object" || !definition.properties) {
+            return false;
+        }
+
+        // Must not have required fields if it's a pure union
+        if (definition.required && definition.required.length > 0) {
+            return false;
+        }
+
+        const propKeys = Object.keys(definition.properties);
+        if (propKeys.length < 2) {
+            return false;
+        }
+
+        // Check if all properties end with "_value" (e.g. bool_value, list_value)
+        const allEndWithValue = propKeys.every(k => k.endsWith("_value"));
+        if (allEndWithValue && (key.endsWith("Value") || key.endsWith("Variant"))) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Mutates the AST in-place by synthesizing a `oneOf` array from the optional properties
+     * and strictly purging the original object layout to force polymorphic evaluation.
+     * 
+     * @param {any} definition The target variant object schema.
+     * @private
+     */
+    private _mutateToOneOf(definition: unknown): void {
+        const propKeys = Object.keys(definition.properties);
+        const oneOfArray: unknown[] = [];
+
+        for (const propKey of propKeys) {
+            const variantSchema = definition.properties[propKey];
+            
+            // Reconstruct a sub-object for each variant, enforcing strict requirement of the single variant property
+            const syntheticVariant = {
+                type: "object",
+                properties: {
+                    [propKey]: variantSchema
+                },
+                required: [propKey],
+                title: variantSchema.description || propKey
+            };
+            
+            oneOfArray.push(syntheticVariant);
+        }
+
+        // Mutate the original definition to become a oneOf root
+        definition.oneOf = oneOfArray;
+        
+        // CRITICAL DESTRUCTIVE MUTATION:
+        // We delete the original properties block. If this is not done, the core engine's layout
+        // orchestrator will attempt to render both a standard static form AND the polymorphic switcher simultaneously.
+        delete definition.properties;
+    }
+}

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin-dbg.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IOpenApiParserPlugin-dbg.js.map

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin-dbg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IOpenApiParserPlugin-dbg.js","names":[],"sources":["IOpenApiParserPlugin.ts"],"sourcesContent":["/**\n * @file IOpenApiParserPlugin.ts\n * @description Contract for OpenAPI schema translation implementations.\n */\n\nimport { ISchema } from \"../../interfaces/ISchema\";\n\n/**\n * Interface defining the boundary for dynamic OpenAPI schema parsing.\n * Any parser plugin must implement this contract to ensure the orchestration engine\n * can seamlessly synthesize MetaUI layouts regardless of the underlying OpenAPI version.\n * \n * @public\n */\nexport interface IOpenApiParserPlugin {\n    /**\n     * Converts a raw OpenAPI schema document into a strictly-typed MetaUI ISchema tree.\n     * Implementations must handle protocol-specific mapping internally.\n     * \n     * @param {any} rawSchema The raw, unparsed OpenAPI document structure.\n     * @param {string} [targetDefinition] Optional name of a specific definition root to target.\n     * @returns {ISchema} A completely normalized and decoupled MetaUI layout definition.\n     */\n    parse(rawSchema: unknown, targetDefinition?: string): ISchema;\n}\n"],"mappings":"","ignoreList":[]}

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin.d.ts

@@ -0,0 +1,26 @@
+declare module "nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin" {
+    /**
+     * @file IOpenApiParserPlugin.ts
+     * @description Contract for OpenAPI schema translation implementations.
+     */
+    import { ISchema } from "nz/co/siliconst/ui5/metaui/interfaces/ISchema";
+    /**
+     * Interface defining the boundary for dynamic OpenAPI schema parsing.
+     * Any parser plugin must implement this contract to ensure the orchestration engine
+     * can seamlessly synthesize MetaUI layouts regardless of the underlying OpenAPI version.
+     *
+     * @public
+     */
+    export interface IOpenApiParserPlugin {
+        /**
+         * Converts a raw OpenAPI schema document into a strictly-typed MetaUI ISchema tree.
+         * Implementations must handle protocol-specific mapping internally.
+         *
+         * @param {any} rawSchema The raw, unparsed OpenAPI document structure.
+         * @param {string} [targetDefinition] Optional name of a specific definition root to target.
+         * @returns {ISchema} A completely normalized and decoupled MetaUI layout definition.
+         */
+        parse(rawSchema: unknown, targetDefinition?: string): ISchema;
+    }
+}
+//# sourceMappingURL=IOpenApiParserPlugin.d.ts.map

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IOpenApiParserPlugin.d.ts","sourceRoot":"../../../../../../../../..","sources":["src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,oEAAoE,CAAC;IACpF;;;OAGG;IAEH,OAAO,EAAE,OAAO,EAAE,MAAM,+CAA+C,CAAC;IAExE;;;;;;OAMG;IACH,UAAiB,oBAAoB;QACjC;;;;;;;WAOG;QACH,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;KACjE;CAEA"}

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IOpenApiParserPlugin.js.map

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IOpenApiParserPlugin.js","names":[],"sources":[],"mappings":"","ignoreList":[]}

package/src/nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin.ts

@@ -0,0 +1,25 @@
+/**
+ * @file IOpenApiParserPlugin.ts
+ * @description Contract for OpenAPI schema translation implementations.
+ */
+
+import { ISchema } from "../../interfaces/ISchema";
+
+/**
+ * Interface defining the boundary for dynamic OpenAPI schema parsing.
+ * Any parser plugin must implement this contract to ensure the orchestration engine
+ * can seamlessly synthesize MetaUI layouts regardless of the underlying OpenAPI version.
+ * 
+ * @public
+ */
+export interface IOpenApiParserPlugin {
+    /**
+     * Converts a raw OpenAPI schema document into a strictly-typed MetaUI ISchema tree.
+     * Implementations must handle protocol-specific mapping internally.
+     * 
+     * @param {any} rawSchema The raw, unparsed OpenAPI document structure.
+     * @param {string} [targetDefinition] Optional name of a specific definition root to target.
+     * @returns {ISchema} A completely normalized and decoupled MetaUI layout definition.
+     */
+    parse(rawSchema: unknown, targetDefinition?: string): ISchema;
+}

package/src/nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser-dbg.js

@@ -0,0 +1,106 @@
+sap.ui.define(["./OpenApiPropertyMapper", "../OpenApiRefResolver"], function (___OpenApiPropertyMapper, ___OpenApiRefResolver) {
+  "use strict";
+
+  /**
+   * @file OpenApi2Parser.ts
+   * @description Native parser for OpenAPI 2.0 (Swagger) specifications.
+   */
+  const OpenApiPropertyMapper = ___OpenApiPropertyMapper["OpenApiPropertyMapper"];
+  const OpenApiRefResolver = ___OpenApiRefResolver["OpenApiRefResolver"];
+  /**
+   * Parser plugin specifically designed for parsing OpenAPI 2.0 (Swagger) schemas.
+   * Responsible for translating OpenAPI 2.0 specific constructs into the MetaUI normalized schema.
+   * 
+   * @public
+   */
+  class OpenApi2Parser {
+    /**
+     * Parses a raw OpenAPI 2.0 document into a normalized MetaUI ISchema tree.
+     * Extracts definitions, normalizes properties, and recursively resolves composition (allOf).
+     * 
+     * @param {any} openApiRoot The root JSON document.
+     * @param {string} [targetDefinition] Optional specific definition to extract. If omitted, uses the first definition available.
+     * @returns {ISchema} The synthesized MetaUI schema structure.
+     * @throws {Error} If the target definition cannot be found in the provided Swagger document.
+     */
+    parse(openApiRoot, targetDefinition) {
+      let targetObject = openApiRoot;
+      if (!targetDefinition) {
+        if (openApiRoot.definitions) {
+          const keys = Object.keys(openApiRoot.definitions);
+          if (keys.length > 0) targetDefinition = keys[0];
+        }
+      }
+      if (targetDefinition) {
+        targetDefinition = targetDefinition.replace("#/components/schemas/", "").replace("#/definitions/", "");
+        if (openApiRoot.definitions && openApiRoot.definitions[targetDefinition]) {
+          targetObject = openApiRoot.definitions[targetDefinition];
+        } else {
+          throw new Error(`[MetaUI OpenApi2Parser] Could not find target definition '${targetDefinition}' in definitions.`);
+        }
+      }
+      if (targetObject.$ref) {
+        const resolved = OpenApiRefResolver.resolve(targetObject.$ref, openApiRoot);
+        if (resolved) {
+          targetObject = {
+            ...resolved,
+            ...targetObject
+          };
+        }
+      }
+      if (Array.isArray(targetObject.allOf)) {
+        let merged = {
+          ...targetObject
+        };
+        delete merged.allOf;
+        for (const subSchema of targetObject.allOf) {
+          let resolvedSub = subSchema;
+          if (subSchema.$ref) {
+            resolvedSub = OpenApiRefResolver.resolve(subSchema.$ref, openApiRoot) || {};
+          }
+          merged = OpenApiPropertyMapper.deepMergeSchemas(merged, resolvedSub);
+        }
+        targetObject = merged;
+      }
+      const schema = {
+        title: targetObject.title || openApiRoot.info?.title || targetDefinition,
+        type: targetObject.type === "array" ? "array" : "object",
+        layoutStrategy: targetObject.type === "array" ? "table" : "form"
+      };
+      if (targetObject.additionalProperties) {
+        if (targetObject.additionalProperties === true) {
+          schema.additionalProperties = true;
+        } else if (typeof targetObject.additionalProperties === "object") {
+          schema.additionalProperties = OpenApiPropertyMapper.mapPropertyMetadata(targetObject.additionalProperties, "value", false, openApiRoot, "2.0");
+        }
+      }
+      if (targetObject.properties) {
+        const requiredFields = Array.isArray(targetObject.required) ? targetObject.required : [];
+        schema.properties = OpenApiPropertyMapper.mapProperties(targetObject.properties, requiredFields, openApiRoot, "2.0");
+      } else if (schema.type === "array" && targetObject.items) {
+        schema.items = OpenApiPropertyMapper.mapPropertyMetadata(targetObject.items, "items", false, openApiRoot, "2.0");
+      }
+      if (openApiRoot.definitions) {
+        schema.definitions = {};
+        for (const key of Object.keys(openApiRoot.definitions)) {
+          const mappedProp = OpenApiPropertyMapper.mapPropertyMetadata(openApiRoot.definitions[key], key, false, openApiRoot, "2.0");
+          schema.definitions[key] = {
+            title: key,
+            type: mappedProp.type === "array" ? "array" : "object",
+            properties: mappedProp.properties,
+            items: mappedProp.items,
+            ui: mappedProp.ui,
+            layoutStrategy: mappedProp.type === "array" ? "table" : "form"
+          };
+        }
+      }
+      return schema;
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.OpenApi2Parser = OpenApi2Parser;
+  return __exports;
+});
+//# sourceMappingURL=OpenApi2Parser-dbg.js.map

package/src/nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser-dbg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApi2Parser-dbg.js","names":["OpenApiPropertyMapper","___OpenApiPropertyMapper","OpenApiRefResolver","___OpenApiRefResolver","OpenApi2Parser","parse","openApiRoot","targetDefinition","targetObject","definitions","keys","Object","length","replace","Error","$ref","resolved","resolve","Array","isArray","allOf","merged","subSchema","resolvedSub","deepMergeSchemas","schema","title","info","type","layoutStrategy","additionalProperties","mapPropertyMetadata","properties","requiredFields","required","mapProperties","items","key","mappedProp","ui","__exports","__esModule"],"sources":["OpenApi2Parser.ts"],"sourcesContent":["/**\n * @file OpenApi2Parser.ts\n * @description Native parser for OpenAPI 2.0 (Swagger) specifications.\n */\n\nimport { IOpenApiParserPlugin } from \"../interfaces/IOpenApiParserPlugin\";\nimport { ISchema } from \"../../interfaces/ISchema\";\nimport { OpenApiPropertyMapper } from \"./OpenApiPropertyMapper\";\nimport { OpenApiRefResolver } from \"../OpenApiRefResolver\";\n\n/**\n * Parser plugin specifically designed for parsing OpenAPI 2.0 (Swagger) schemas.\n * Responsible for translating OpenAPI 2.0 specific constructs into the MetaUI normalized schema.\n * \n * @public\n */\nexport class OpenApi2Parser implements IOpenApiParserPlugin {\n    /**\n     * Parses a raw OpenAPI 2.0 document into a normalized MetaUI ISchema tree.\n     * Extracts definitions, normalizes properties, and recursively resolves composition (allOf).\n     * \n     * @param {any} openApiRoot The root JSON document.\n     * @param {string} [targetDefinition] Optional specific definition to extract. If omitted, uses the first definition available.\n     * @returns {ISchema} The synthesized MetaUI schema structure.\n     * @throws {Error} If the target definition cannot be found in the provided Swagger document.\n     */\n    public parse(openApiRoot: unknown, targetDefinition?: string): ISchema {\n        let targetObject = openApiRoot;\n\n        if (!targetDefinition) {\n            if (openApiRoot.definitions) {\n                const keys = Object.keys(openApiRoot.definitions);\n                if (keys.length > 0) targetDefinition = keys[0];\n            }\n        }\n\n        if (targetDefinition) {\n            targetDefinition = targetDefinition.replace(\"#/components/schemas/\", \"\").replace(\"#/definitions/\", \"\");\n            if (openApiRoot.definitions && openApiRoot.definitions[targetDefinition]) {\n                targetObject = openApiRoot.definitions[targetDefinition];\n            } else {\n                throw new Error(`[MetaUI OpenApi2Parser] Could not find target definition '${targetDefinition}' in definitions.`);\n            }\n        }\n\n        if (targetObject.$ref) {\n            const resolved = OpenApiRefResolver.resolve(targetObject.$ref, openApiRoot);\n            if (resolved) {\n                targetObject = { ...resolved, ...targetObject };\n            }\n        }\n\n        if (Array.isArray(targetObject.allOf)) {\n            let merged = { ...targetObject };\n            delete merged.allOf;\n            for (const subSchema of targetObject.allOf) {\n                let resolvedSub = subSchema;\n                if (subSchema.$ref) {\n                    resolvedSub = OpenApiRefResolver.resolve(subSchema.$ref, openApiRoot) || {};\n                }\n                merged = OpenApiPropertyMapper.deepMergeSchemas(merged, resolvedSub);\n            }\n            targetObject = merged;\n        }\n\n        const schema: ISchema = {\n            title: targetObject.title || openApiRoot.info?.title || targetDefinition,\n            type: targetObject.type === \"array\" ? \"array\" : \"object\",\n            layoutStrategy: targetObject.type === \"array\" ? \"table\" : \"form\"\n        };\n\n        if (targetObject.additionalProperties) {\n            if (targetObject.additionalProperties === true) {\n                schema.additionalProperties = true;\n            } else if (typeof targetObject.additionalProperties === \"object\") {\n                schema.additionalProperties = OpenApiPropertyMapper.mapPropertyMetadata(targetObject.additionalProperties, \"value\", false, openApiRoot, \"2.0\");\n            }\n        }\n\n        if (targetObject.properties) {\n            const requiredFields = Array.isArray(targetObject.required) ? targetObject.required : [];\n            schema.properties = OpenApiPropertyMapper.mapProperties(targetObject.properties, requiredFields, openApiRoot, \"2.0\");\n        } else if (schema.type === \"array\" && targetObject.items) {\n            schema.items = OpenApiPropertyMapper.mapPropertyMetadata(targetObject.items, \"items\", false, openApiRoot, \"2.0\");\n        }\n\n        if (openApiRoot.definitions) {\n            schema.definitions = {};\n            for (const key of Object.keys(openApiRoot.definitions)) {\n                const mappedProp = OpenApiPropertyMapper.mapPropertyMetadata(openApiRoot.definitions[key], key, false, openApiRoot, \"2.0\");\n                schema.definitions[key] = {\n                    title: key,\n                    type: mappedProp.type === \"array\" ? \"array\" : \"object\",\n                    properties: mappedProp.properties,\n                    items: mappedProp.items,\n                    ui: mappedProp.ui,\n                    layoutStrategy: mappedProp.type === \"array\" ? \"table\" : \"form\"\n                };\n            }\n        }\n\n        return schema;\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser.d.ts

@@ -0,0 +1,27 @@
+declare module "nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser" {
+    /**
+     * @file OpenApi2Parser.ts
+     * @description Native parser for OpenAPI 2.0 (Swagger) specifications.
+     */
+    import { IOpenApiParserPlugin } from "nz/co/siliconst/ui5/metaui/openapi/interfaces/IOpenApiParserPlugin";
+    import { ISchema } from "nz/co/siliconst/ui5/metaui/interfaces/ISchema";
+    /**
+     * Parser plugin specifically designed for parsing OpenAPI 2.0 (Swagger) schemas.
+     * Responsible for translating OpenAPI 2.0 specific constructs into the MetaUI normalized schema.
+     *
+     * @public
+     */
+    export class OpenApi2Parser implements IOpenApiParserPlugin {
+        /**
+         * Parses a raw OpenAPI 2.0 document into a normalized MetaUI ISchema tree.
+         * Extracts definitions, normalizes properties, and recursively resolves composition (allOf).
+         *
+         * @param {any} openApiRoot The root JSON document.
+         * @param {string} [targetDefinition] Optional specific definition to extract. If omitted, uses the first definition available.
+         * @returns {ISchema} The synthesized MetaUI schema structure.
+         * @throws {Error} If the target definition cannot be found in the provided Swagger document.
+         */
+        parse(openApiRoot: unknown, targetDefinition?: string): ISchema;
+    }
+}
+//# sourceMappingURL=OpenApi2Parser.d.ts.map

package/src/nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApi2Parser.d.ts","sourceRoot":"../../../../../../../../..","sources":["src/nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,2DAA2D,CAAC;IAC3E;;;OAGG;IAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,oEAAoE,CAAC;IAC1G,OAAO,EAAE,OAAO,EAAE,MAAM,+CAA+C,CAAC;IAIxE;;;;;OAKG;IACH,MAAa,cAAe,YAAW,oBAAoB;QACvD;;;;;;;;WAQG;QACI,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO;KA6EzE;CAEA"}

package/src/nz/co/siliconst/ui5/metaui/openapi/parsers/OpenApi2Parser.js

@@ -0,0 +1,2 @@
+sap.ui.define(["./OpenApiPropertyMapper","../OpenApiRefResolver"],function(e,i){"use strict";const t=e["OpenApiPropertyMapper"];const r=i["OpenApiRefResolver"];class a{parse(e,i){let a=e;if(!i){if(e.definitions){const t=Object.keys(e.definitions);if(t.length>0)i=t[0]}}if(i){i=i.replace("#/components/schemas/","").replace("#/definitions/","");if(e.definitions&&e.definitions[i]){a=e.definitions[i]}else{throw new Error(`[MetaUI OpenApi2Parser] Could not find target definition '${i}' in definitions.`)}}if(a.$ref){const i=r.resolve(a.$ref,e);if(i){a={...i,...a}}}if(Array.isArray(a.allOf)){let i={...a};delete i.allOf;for(const o of a.allOf){let a=o;if(o.$ref){a=r.resolve(o.$ref,e)||{}}i=t.deepMergeSchemas(i,a)}a=i}const o={title:a.title||e.info?.title||i,type:a.type==="array"?"array":"object",layoutStrategy:a.type==="array"?"table":"form"};if(a.additionalProperties){if(a.additionalProperties===true){o.additionalProperties=true}else if(typeof a.additionalProperties==="object"){o.additionalProperties=t.mapPropertyMetadata(a.additionalProperties,"value",false,e,"2.0")}}if(a.properties){const i=Array.isArray(a.required)?a.required:[];o.properties=t.mapProperties(a.properties,i,e,"2.0")}else if(o.type==="array"&&a.items){o.items=t.mapPropertyMetadata(a.items,"items",false,e,"2.0")}if(e.definitions){o.definitions={};for(const i of Object.keys(e.definitions)){const r=t.mapPropertyMetadata(e.definitions[i],i,false,e,"2.0");o.definitions[i]={title:i,type:r.type==="array"?"array":"object",properties:r.properties,items:r.items,ui:r.ui,layoutStrategy:r.type==="array"?"table":"form"}}}return o}}var o={__esModule:true};o.OpenApi2Parser=a;return o});
+//# sourceMappingURL=OpenApi2Parser.js.map