@microsoft/m365-spec-parser 0.0.2-alpha.0

package/dist/index.node.cjs.js

@@ -0,0 +1,1372 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SwaggerParser = require('@apidevtools/swagger-parser');
+var converter = require('swagger2openapi');
+var jsyaml = require('js-yaml');
+var fs = require('fs-extra');
+var path = require('path');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var SwaggerParser__default = /*#__PURE__*/_interopDefaultLegacy(SwaggerParser);
+var converter__default = /*#__PURE__*/_interopDefaultLegacy(converter);
+var jsyaml__default = /*#__PURE__*/_interopDefaultLegacy(jsyaml);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * An enum that represents the types of errors that can occur during validation.
+ */
+exports.ErrorType = void 0;
+(function (ErrorType) {
+    ErrorType["SpecNotValid"] = "spec-not-valid";
+    ErrorType["RemoteRefNotSupported"] = "remote-ref-not-supported";
+    ErrorType["NoServerInformation"] = "no-server-information";
+    ErrorType["UrlProtocolNotSupported"] = "url-protocol-not-supported";
+    ErrorType["RelativeServerUrlNotSupported"] = "relative-server-url-not-supported";
+    ErrorType["NoSupportedApi"] = "no-supported-api";
+    ErrorType["NoExtraAPICanBeAdded"] = "no-extra-api-can-be-added";
+    ErrorType["ResolveServerUrlFailed"] = "resolve-server-url-failed";
+    ErrorType["SwaggerNotSupported"] = "swagger-not-supported";
+    ErrorType["MultipleAPIKeyNotSupported"] = "multiple-api-key-not-supported";
+    ErrorType["ListFailed"] = "list-failed";
+    ErrorType["listSupportedAPIInfoFailed"] = "list-supported-api-info-failed";
+    ErrorType["FilterSpecFailed"] = "filter-spec-failed";
+    ErrorType["UpdateManifestFailed"] = "update-manifest-failed";
+    ErrorType["GenerateAdaptiveCardFailed"] = "generate-adaptive-card-failed";
+    ErrorType["GenerateFailed"] = "generate-failed";
+    ErrorType["ValidateFailed"] = "validate-failed";
+    ErrorType["Cancelled"] = "cancelled";
+    ErrorType["Unknown"] = "unknown";
+})(exports.ErrorType || (exports.ErrorType = {}));
+/**
+ * An enum that represents the types of warnings that can occur during validation.
+ */
+exports.WarningType = void 0;
+(function (WarningType) {
+    WarningType["OperationIdMissing"] = "operationid-missing";
+    WarningType["GenerateCardFailed"] = "generate-card-failed";
+    WarningType["OperationOnlyContainsOptionalParam"] = "operation-only-contains-optional-param";
+    WarningType["ConvertSwaggerToOpenAPI"] = "convert-swagger-to-openapi";
+    WarningType["Unknown"] = "unknown";
+})(exports.WarningType || (exports.WarningType = {}));
+/**
+ * An enum that represents the validation status of an OpenAPI specification file.
+ */
+exports.ValidationStatus = void 0;
+(function (ValidationStatus) {
+    ValidationStatus[ValidationStatus["Valid"] = 0] = "Valid";
+    ValidationStatus[ValidationStatus["Warning"] = 1] = "Warning";
+    ValidationStatus[ValidationStatus["Error"] = 2] = "Error";
+})(exports.ValidationStatus || (exports.ValidationStatus = {}));
+
+// Copyright (c) Microsoft Corporation.
+class ConstantString {
+}
+ConstantString.CancelledMessage = "Operation is cancelled.";
+ConstantString.NoServerInformation = "No server information is found in the OpenAPI description document.";
+ConstantString.RemoteRefNotSupported = "Remote reference is not supported: %s.";
+ConstantString.MissingOperationId = "Missing operationIds: %s.";
+ConstantString.NoSupportedApi = "No supported API is found in the OpenAPI description document: only GET and POST methods are supported, additionally, there can be at most one required parameter, and no auth is allowed.";
+ConstantString.AdditionalPropertiesNotSupported = "'additionalProperties' is not supported, and will be ignored.";
+ConstantString.SchemaNotSupported = "'oneOf', 'anyOf', and 'not' schema are not supported: %s.";
+ConstantString.UnknownSchema = "Unknown schema: %s.";
+ConstantString.UrlProtocolNotSupported = "Server url is not correct: protocol %s is not supported, you should use https protocol instead.";
+ConstantString.RelativeServerUrlNotSupported = "Server url is not correct: relative server url is not supported.";
+ConstantString.ResolveServerUrlFailed = "Unable to resolve the server URL: please make sure that the environment variable %s is defined.";
+ConstantString.OperationOnlyContainsOptionalParam = "Operation %s contains multiple optional parameters. The first optional parameter is used for this command.";
+ConstantString.ConvertSwaggerToOpenAPI = "The Swagger 2.0 file has been converted to OpenAPI 3.0.";
+ConstantString.SwaggerNotSupported = "Swagger 2.0 is not supported. Please convert to OpenAPI 3.0 manually before proceeding.";
+ConstantString.MultipleAPIKeyNotSupported = "Multiple API keys are not supported. Please make sure that all selected APIs use the same API key.";
+ConstantString.WrappedCardVersion = "devPreview";
+ConstantString.WrappedCardSchema = "https://developer.microsoft.com/json-schemas/teams/vDevPreview/MicrosoftTeams.ResponseRenderingTemplate.schema.json";
+ConstantString.WrappedCardResponseLayout = "list";
+ConstantString.GetMethod = "get";
+ConstantString.PostMethod = "post";
+ConstantString.AdaptiveCardVersion = "1.5";
+ConstantString.AdaptiveCardSchema = "http://adaptivecards.io/schemas/adaptive-card.json";
+ConstantString.AdaptiveCardType = "AdaptiveCard";
+ConstantString.TextBlockType = "TextBlock";
+ConstantString.ContainerType = "Container";
+ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
+ConstantString.ResponseCodeFor20X = [
+    "200",
+    "201",
+    "202",
+    "203",
+    "204",
+    "205",
+    "206",
+    "207",
+    "208",
+    "226",
+    "default",
+];
+ConstantString.AllOperationMethods = [
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "head",
+    "options",
+    "trace",
+];
+// TODO: update after investigating the usage of these constants.
+ConstantString.WellknownResultNames = [
+    "result",
+    "data",
+    "items",
+    "root",
+    "matches",
+    "queries",
+    "list",
+    "output",
+];
+ConstantString.WellknownTitleName = ["title", "name", "summary", "caption", "subject", "label"];
+ConstantString.WellknownSubtitleName = [
+    "subtitle",
+    "id",
+    "uid",
+    "description",
+    "desc",
+    "detail",
+];
+ConstantString.WellknownImageName = [
+    "image",
+    "icon",
+    "avatar",
+    "picture",
+    "photo",
+    "logo",
+    "pic",
+    "thumbnail",
+    "img",
+];
+ConstantString.ShortDescriptionMaxLens = 80;
+ConstantString.FullDescriptionMaxLens = 4000;
+ConstantString.CommandDescriptionMaxLens = 128;
+ConstantString.ParameterDescriptionMaxLens = 128;
+ConstantString.CommandTitleMaxLens = 32;
+ConstantString.ParameterTitleMaxLens = 32;
+
+// Copyright (c) Microsoft Corporation.
+class SpecParserError extends Error {
+    constructor(message, errorType) {
+        super(message);
+        this.errorType = errorType;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class Utils {
+    static checkParameters(paramObject) {
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+        };
+        if (!paramObject) {
+            return paramResult;
+        }
+        for (let i = 0; i < paramObject.length; i++) {
+            const param = paramObject[i];
+            const schema = param.schema;
+            const isRequiredWithoutDefault = param.required && schema.default === undefined;
+            if (param.in === "header" || param.in === "cookie") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                }
+                continue;
+            }
+            if (schema.type !== "boolean" &&
+                schema.type !== "string" &&
+                schema.type !== "number" &&
+                schema.type !== "integer") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                }
+                continue;
+            }
+            if (param.in === "query" || param.in === "path") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.requiredNum = paramResult.requiredNum + 1;
+                }
+                else {
+                    paramResult.optionalNum = paramResult.optionalNum + 1;
+                }
+            }
+        }
+        return paramResult;
+    }
+    static checkPostBody(schema, isRequired = false) {
+        var _a;
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+        };
+        if (Object.keys(schema).length === 0) {
+            return paramResult;
+        }
+        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            if (isRequiredWithoutDefault) {
+                paramResult.requiredNum = paramResult.requiredNum + 1;
+            }
+            else {
+                paramResult.optionalNum = paramResult.optionalNum + 1;
+            }
+        }
+        else if (schema.type === "object") {
+            const { properties } = schema;
+            for (const property in properties) {
+                let isRequired = false;
+                if (schema.required && ((_a = schema.required) === null || _a === void 0 ? void 0 : _a.indexOf(property)) >= 0) {
+                    isRequired = true;
+                }
+                const result = Utils.checkPostBody(properties[property], isRequired);
+                paramResult.requiredNum += result.requiredNum;
+                paramResult.optionalNum += result.optionalNum;
+                paramResult.isValid = paramResult.isValid && result.isValid;
+            }
+        }
+        else {
+            if (isRequiredWithoutDefault) {
+                paramResult.isValid = false;
+            }
+        }
+        return paramResult;
+    }
+    /**
+     * Checks if the given API is supported.
+     * @param {string} method - The HTTP method of the API.
+     * @param {string} path - The path of the API.
+     * @param {OpenAPIV3.Document} spec - The OpenAPI specification document.
+     * @returns {boolean} - Returns true if the API is supported, false otherwise.
+     * @description The following APIs are supported:
+     * 1. only support Get/Post operation without auth property
+     * 2. parameter inside query or path only support string, number, boolean and integer
+     * 3. parameter inside post body only support string, number, boolean, integer and object
+     * 4. request body + required parameters <= 1
+     * 5. response body should be “application/json” and not empty, and response code should be 20X
+     * 6. only support request body with “application/json” content type
+     */
+    static isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const pathObj = spec.paths[path];
+        method = method.toLocaleLowerCase();
+        if (pathObj) {
+            if ((method === ConstantString.PostMethod || method === ConstantString.GetMethod) &&
+                pathObj[method]) {
+                const securities = pathObj[method].security;
+                const authArray = Utils.getAuthArray(securities, spec);
+                if (!Utils.isSupportedAuth(authArray, allowAPIKeyAuth, allowOauth2)) {
+                    return false;
+                }
+                const operationObject = pathObj[method];
+                if (!allowMissingId && !operationObject.operationId) {
+                    return false;
+                }
+                const paramObject = operationObject.parameters;
+                const requestBody = operationObject.requestBody;
+                const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+                const mediaTypesCount = Object.keys((requestBody === null || requestBody === void 0 ? void 0 : requestBody.content) || {}).length;
+                if (mediaTypesCount > 1) {
+                    return false;
+                }
+                const responseJson = Utils.getResponseJson(operationObject);
+                if (Object.keys(responseJson).length === 0) {
+                    return false;
+                }
+                let requestBodyParamResult = {
+                    requiredNum: 0,
+                    optionalNum: 0,
+                    isValid: true,
+                };
+                if (requestJsonBody) {
+                    const requestBodySchema = requestJsonBody.schema;
+                    requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required);
+                }
+                if (!requestBodyParamResult.isValid) {
+                    return false;
+                }
+                const paramResult = Utils.checkParameters(paramObject);
+                if (!paramResult.isValid) {
+                    return false;
+                }
+                if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
+                    if (allowMultipleParameters &&
+                        requestBodyParamResult.requiredNum + paramResult.requiredNum <= 5) {
+                        return true;
+                    }
+                    return false;
+                }
+                else if (requestBodyParamResult.requiredNum +
+                    requestBodyParamResult.optionalNum +
+                    paramResult.requiredNum +
+                    paramResult.optionalNum ===
+                    0) {
+                    return false;
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static isSupportedAuth(authSchemaArray, allowAPIKeyAuth, allowOauth2) {
+        if (authSchemaArray.length === 0) {
+            return true;
+        }
+        if (allowAPIKeyAuth || allowOauth2) {
+            // Currently we don't support multiple auth in one operation
+            if (authSchemaArray.length > 0 && authSchemaArray.every((auths) => auths.length > 1)) {
+                return false;
+            }
+            for (const auths of authSchemaArray) {
+                if (auths.length === 1) {
+                    if (!allowOauth2 && allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authSchema)) {
+                        return true;
+                    }
+                    else if (!allowAPIKeyAuth && allowOauth2 && Utils.isBearerTokenAuth(auths[0].authSchema)) {
+                        return true;
+                    }
+                    else if (allowAPIKeyAuth &&
+                        allowOauth2 &&
+                        (Utils.isAPIKeyAuth(auths[0].authSchema) || Utils.isBearerTokenAuth(auths[0].authSchema))) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static isAPIKeyAuth(authSchema) {
+        return authSchema.type === "apiKey";
+    }
+    static isBearerTokenAuth(authSchema) {
+        return (authSchema.type === "oauth2" ||
+            authSchema.type === "openIdConnect" ||
+            (authSchema.type === "http" && authSchema.scheme === "bearer"));
+    }
+    static getAuthArray(securities, spec) {
+        var _a;
+        const result = [];
+        const securitySchemas = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.securitySchemes;
+        if (securities && securitySchemas) {
+            for (let i = 0; i < securities.length; i++) {
+                const security = securities[i];
+                const authArray = [];
+                for (const name in security) {
+                    const auth = securitySchemas[name];
+                    authArray.push({
+                        authSchema: auth,
+                        name: name,
+                    });
+                }
+                if (authArray.length > 0) {
+                    result.push(authArray);
+                }
+            }
+        }
+        result.sort((a, b) => a[0].name.localeCompare(b[0].name));
+        return result;
+    }
+    static updateFirstLetter(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    static getResponseJson(operationObject) {
+        var _a, _b;
+        let json = {};
+        for (const code of ConstantString.ResponseCodeFor20X) {
+            const responseObject = (_a = operationObject === null || operationObject === void 0 ? void 0 : operationObject.responses) === null || _a === void 0 ? void 0 : _a[code];
+            const mediaTypesCount = Object.keys((responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) || {}).length;
+            if (mediaTypesCount > 1) {
+                return {};
+            }
+            if ((_b = responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) === null || _b === void 0 ? void 0 : _b["application/json"]) {
+                json = responseObject.content["application/json"];
+                break;
+            }
+        }
+        return json;
+    }
+    static convertPathToCamelCase(path) {
+        const pathSegments = path.split(/[./{]/);
+        const camelCaseSegments = pathSegments.map((segment) => {
+            segment = segment.replace(/}/g, "");
+            return segment.charAt(0).toUpperCase() + segment.slice(1);
+        });
+        const camelCasePath = camelCaseSegments.join("");
+        return camelCasePath;
+    }
+    static getUrlProtocol(urlString) {
+        try {
+            const url = new URL(urlString);
+            return url.protocol;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    static resolveServerUrl(url) {
+        const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
+        let matches = placeHolderReg.exec(url);
+        let newUrl = url;
+        while (matches != null) {
+            const envVar = matches[1];
+            const envVal = process.env[envVar];
+            if (!envVal) {
+                throw new Error(Utils.format(ConstantString.ResolveServerUrlFailed, envVar));
+            }
+            else {
+                newUrl = newUrl.replace(matches[0], envVal);
+            }
+            matches = placeHolderReg.exec(url);
+        }
+        return newUrl;
+    }
+    static checkServerUrl(servers) {
+        const errors = [];
+        let serverUrl;
+        try {
+            serverUrl = Utils.resolveServerUrl(servers[0].url);
+        }
+        catch (err) {
+            errors.push({
+                type: exports.ErrorType.ResolveServerUrlFailed,
+                content: err.message,
+                data: servers,
+            });
+            return errors;
+        }
+        const protocol = Utils.getUrlProtocol(serverUrl);
+        if (!protocol) {
+            // Relative server url is not supported
+            errors.push({
+                type: exports.ErrorType.RelativeServerUrlNotSupported,
+                content: ConstantString.RelativeServerUrlNotSupported,
+                data: servers,
+            });
+        }
+        else if (protocol !== "https:") {
+            // Http server url is not supported
+            const protocolString = protocol.slice(0, -1);
+            errors.push({
+                type: exports.ErrorType.UrlProtocolNotSupported,
+                content: Utils.format(ConstantString.UrlProtocolNotSupported, protocol.slice(0, -1)),
+                data: protocolString,
+            });
+        }
+        return errors;
+    }
+    static validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const errors = [];
+        let hasTopLevelServers = false;
+        let hasPathLevelServers = false;
+        let hasOperationLevelServers = false;
+        if (spec.servers && spec.servers.length >= 1) {
+            hasTopLevelServers = true;
+            // for multiple server, we only use the first url
+            const serverErrors = Utils.checkServerUrl(spec.servers);
+            errors.push(...serverErrors);
+        }
+        const paths = spec.paths;
+        for (const path in paths) {
+            const methods = paths[path];
+            if ((methods === null || methods === void 0 ? void 0 : methods.servers) && methods.servers.length >= 1) {
+                hasPathLevelServers = true;
+                const serverErrors = Utils.checkServerUrl(methods.servers);
+                errors.push(...serverErrors);
+            }
+            for (const method in methods) {
+                const operationObject = methods[method];
+                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2)) {
+                    if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
+                        hasOperationLevelServers = true;
+                        const serverErrors = Utils.checkServerUrl(operationObject.servers);
+                        errors.push(...serverErrors);
+                    }
+                }
+            }
+        }
+        if (!hasTopLevelServers && !hasPathLevelServers && !hasOperationLevelServers) {
+            errors.push({
+                type: exports.ErrorType.NoServerInformation,
+                content: ConstantString.NoServerInformation,
+            });
+        }
+        return errors;
+    }
+    static isWellKnownName(name, wellknownNameList) {
+        for (let i = 0; i < wellknownNameList.length; i++) {
+            name = name.replace(/_/g, "").replace(/-/g, "");
+            if (name.toLowerCase().includes(wellknownNameList[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static generateParametersFromSchema(schema, name, allowMultipleParameters, isRequired = false) {
+        var _a, _b;
+        const requiredParams = [];
+        const optionalParams = [];
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            const parameter = {
+                name: name,
+                title: Utils.updateFirstLetter(name).slice(0, ConstantString.ParameterTitleMaxLens),
+                description: ((_a = schema.description) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.ParameterDescriptionMaxLens),
+            };
+            if (allowMultipleParameters) {
+                Utils.updateParameterWithInputType(schema, parameter);
+            }
+            if (isRequired && schema.default === undefined) {
+                requiredParams.push(parameter);
+            }
+            else {
+                optionalParams.push(parameter);
+            }
+        }
+        else if (schema.type === "object") {
+            const { properties } = schema;
+            for (const property in properties) {
+                let isRequired = false;
+                if (schema.required && ((_b = schema.required) === null || _b === void 0 ? void 0 : _b.indexOf(property)) >= 0) {
+                    isRequired = true;
+                }
+                const [requiredP, optionalP] = Utils.generateParametersFromSchema(properties[property], property, allowMultipleParameters, isRequired);
+                requiredParams.push(...requiredP);
+                optionalParams.push(...optionalP);
+            }
+        }
+        return [requiredParams, optionalParams];
+    }
+    static updateParameterWithInputType(schema, param) {
+        if (schema.enum) {
+            param.inputType = "choiceset";
+            param.choices = [];
+            for (let i = 0; i < schema.enum.length; i++) {
+                param.choices.push({
+                    title: schema.enum[i],
+                    value: schema.enum[i],
+                });
+            }
+        }
+        else if (schema.type === "string") {
+            param.inputType = "text";
+        }
+        else if (schema.type === "integer" || schema.type === "number") {
+            param.inputType = "number";
+        }
+        else if (schema.type === "boolean") {
+            param.inputType = "toggle";
+        }
+        if (schema.default) {
+            param.value = schema.default;
+        }
+    }
+    static parseApiInfo(operationItem, allowMultipleParameters) {
+        var _a, _b;
+        const requiredParams = [];
+        const optionalParams = [];
+        const paramObject = operationItem.parameters;
+        if (paramObject) {
+            paramObject.forEach((param) => {
+                var _a;
+                const parameter = {
+                    name: param.name,
+                    title: Utils.updateFirstLetter(param.name).slice(0, ConstantString.ParameterTitleMaxLens),
+                    description: ((_a = param.description) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.ParameterDescriptionMaxLens),
+                };
+                const schema = param.schema;
+                if (allowMultipleParameters && schema) {
+                    Utils.updateParameterWithInputType(schema, parameter);
+                }
+                if (param.in !== "header" && param.in !== "cookie") {
+                    if (param.required && (schema === null || schema === void 0 ? void 0 : schema.default) === undefined) {
+                        requiredParams.push(parameter);
+                    }
+                    else {
+                        optionalParams.push(parameter);
+                    }
+                }
+            });
+        }
+        if (operationItem.requestBody) {
+            const requestBody = operationItem.requestBody;
+            const requestJson = requestBody.content["application/json"];
+            if (Object.keys(requestJson).length !== 0) {
+                const schema = requestJson.schema;
+                const [requiredP, optionalP] = Utils.generateParametersFromSchema(schema, "requestBody", allowMultipleParameters, requestBody.required);
+                requiredParams.push(...requiredP);
+                optionalParams.push(...optionalP);
+            }
+        }
+        const operationId = operationItem.operationId;
+        const parameters = [];
+        if (requiredParams.length !== 0) {
+            parameters.push(...requiredParams);
+        }
+        else {
+            parameters.push(optionalParams[0]);
+        }
+        const command = {
+            context: ["compose"],
+            type: "query",
+            title: ((_a = operationItem.summary) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.CommandTitleMaxLens),
+            id: operationId,
+            parameters: parameters,
+            description: ((_b = operationItem.description) !== null && _b !== void 0 ? _b : "").slice(0, ConstantString.CommandDescriptionMaxLens),
+        };
+        let warning = undefined;
+        if (requiredParams.length === 0 && optionalParams.length > 1) {
+            warning = {
+                type: exports.WarningType.OperationOnlyContainsOptionalParam,
+                content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, operationId),
+                data: operationId,
+            };
+        }
+        return [command, warning];
+    }
+    static listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const paths = spec.paths;
+        const result = {};
+        for (const path in paths) {
+            const methods = paths[path];
+            for (const method in methods) {
+                // For developer preview, only support GET operation with only 1 parameter without auth
+                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2)) {
+                    const operationObject = methods[method];
+                    result[`${method.toUpperCase()} ${path}`] = operationObject;
+                }
+            }
+        }
+        return result;
+    }
+    static validateSpec(spec, parser, isSwaggerFile, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const errors = [];
+        const warnings = [];
+        if (isSwaggerFile) {
+            warnings.push({
+                type: exports.WarningType.ConvertSwaggerToOpenAPI,
+                content: ConstantString.ConvertSwaggerToOpenAPI,
+            });
+        }
+        // Server validation
+        const serverErrors = Utils.validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2);
+        errors.push(...serverErrors);
+        // Remote reference not supported
+        const refPaths = parser.$refs.paths();
+        // refPaths [0] is the current spec file path
+        if (refPaths.length > 1) {
+            errors.push({
+                type: exports.ErrorType.RemoteRefNotSupported,
+                content: Utils.format(ConstantString.RemoteRefNotSupported, refPaths.join(", ")),
+                data: refPaths,
+            });
+        }
+        // No supported API
+        const apiMap = Utils.listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2);
+        if (Object.keys(apiMap).length === 0) {
+            errors.push({
+                type: exports.ErrorType.NoSupportedApi,
+                content: ConstantString.NoSupportedApi,
+            });
+        }
+        // OperationId missing
+        const apisMissingOperationId = [];
+        for (const key in apiMap) {
+            const pathObjectItem = apiMap[key];
+            if (!pathObjectItem.operationId) {
+                apisMissingOperationId.push(key);
+            }
+        }
+        if (apisMissingOperationId.length > 0) {
+            warnings.push({
+                type: exports.WarningType.OperationIdMissing,
+                content: Utils.format(ConstantString.MissingOperationId, apisMissingOperationId.join(", ")),
+                data: apisMissingOperationId,
+            });
+        }
+        let status = exports.ValidationStatus.Valid;
+        if (warnings.length > 0 && errors.length === 0) {
+            status = exports.ValidationStatus.Warning;
+        }
+        else if (errors.length > 0) {
+            status = exports.ValidationStatus.Error;
+        }
+        return {
+            status,
+            warnings,
+            errors,
+        };
+    }
+    static format(str, ...args) {
+        let index = 0;
+        return str.replace(/%s/g, () => {
+            const arg = args[index++];
+            return arg !== undefined ? arg : "";
+        });
+    }
+    static getSafeRegistrationIdEnvName(authName) {
+        if (!authName) {
+            return "";
+        }
+        let safeRegistrationIdEnvName = authName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+        if (!safeRegistrationIdEnvName.match(/^[A-Z]/)) {
+            safeRegistrationIdEnvName = "PREFIX_" + safeRegistrationIdEnvName;
+        }
+        return safeRegistrationIdEnvName;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class SpecFilter {
+    static specFilter(filter, unResolveSpec, resolvedSpec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        try {
+            const newSpec = Object.assign({}, unResolveSpec);
+            const newPaths = {};
+            for (const filterItem of filter) {
+                const [method, path] = filterItem.split(" ");
+                const methodName = method.toLowerCase();
+                if (!Utils.isSupportedApi(methodName, path, resolvedSpec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2)) {
+                    continue;
+                }
+                if (!newPaths[path]) {
+                    newPaths[path] = Object.assign({}, unResolveSpec.paths[path]);
+                    for (const m of ConstantString.AllOperationMethods) {
+                        delete newPaths[path][m];
+                    }
+                }
+                newPaths[path][methodName] = unResolveSpec.paths[path][methodName];
+                // Add the operationId if missing
+                if (!newPaths[path][methodName].operationId) {
+                    newPaths[path][methodName].operationId = `${methodName}${Utils.convertPathToCamelCase(path)}`;
+                }
+            }
+            newSpec.paths = newPaths;
+            return newSpec;
+        }
+        catch (err) {
+            throw new SpecParserError(err.toString(), exports.ErrorType.FilterSpecFailed);
+        }
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class ManifestUpdater {
+    static updateManifest(manifestPath, outputSpecPath, adaptiveCardFolder, spec, allowMultipleParameters, auth) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const originalManifest = yield fs__default["default"].readJSON(manifestPath);
+                const updatedPart = {};
+                const [commands, warnings] = yield ManifestUpdater.generateCommands(spec, adaptiveCardFolder, manifestPath, allowMultipleParameters);
+                const composeExtension = {
+                    composeExtensionType: "apiBased",
+                    apiSpecificationFile: ManifestUpdater.getRelativePath(manifestPath, outputSpecPath),
+                    commands: commands,
+                };
+                if (auth) {
+                    if (Utils.isAPIKeyAuth(auth)) {
+                        auth = auth;
+                        const safeApiSecretRegistrationId = Utils.getSafeRegistrationIdEnvName(`${auth.name}_${ConstantString.RegistrationIdPostfix}`);
+                        composeExtension.authorization = {
+                            authType: "apiSecretServiceAuth",
+                            apiSecretServiceAuthConfiguration: {
+                                apiSecretRegistrationId: `\${{${safeApiSecretRegistrationId}}}`,
+                            },
+                        };
+                    }
+                    else if (Utils.isBearerTokenAuth(auth)) {
+                        composeExtension.authorization = {
+                            authType: "microsoftEntra",
+                            microsoftEntraConfiguration: {
+                                supportsSingleSignOn: true,
+                            },
+                        };
+                        updatedPart.webApplicationInfo = {
+                            id: "${{AAD_APP_CLIENT_ID}}",
+                            resource: "api://${{DOMAIN}}/${{AAD_APP_CLIENT_ID}}",
+                        };
+                    }
+                }
+                updatedPart.description = {
+                    short: spec.info.title.slice(0, ConstantString.ShortDescriptionMaxLens),
+                    full: (_b = ((_a = spec.info.description) !== null && _a !== void 0 ? _a : originalManifest.description.full)) === null || _b === void 0 ? void 0 : _b.slice(0, ConstantString.FullDescriptionMaxLens),
+                };
+                updatedPart.composeExtensions = [composeExtension];
+                const updatedManifest = Object.assign(Object.assign({}, originalManifest), updatedPart);
+                return [updatedManifest, warnings];
+            }
+            catch (err) {
+                throw new SpecParserError(err.toString(), exports.ErrorType.UpdateManifestFailed);
+            }
+        });
+    }
+    static generateCommands(spec, adaptiveCardFolder, manifestPath, allowMultipleParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const paths = spec.paths;
+            const commands = [];
+            const warnings = [];
+            if (paths) {
+                for (const pathUrl in paths) {
+                    const pathItem = paths[pathUrl];
+                    if (pathItem) {
+                        const operations = pathItem;
+                        // Currently only support GET and POST method
+                        for (const method in operations) {
+                            if (method === ConstantString.PostMethod || method === ConstantString.GetMethod) {
+                                const operationItem = operations[method];
+                                if (operationItem) {
+                                    const [command, warning] = Utils.parseApiInfo(operationItem, allowMultipleParameters);
+                                    const adaptiveCardPath = path__default["default"].join(adaptiveCardFolder, command.id + ".json");
+                                    command.apiResponseRenderingTemplateFile = (yield fs__default["default"].pathExists(adaptiveCardPath))
+                                        ? ManifestUpdater.getRelativePath(manifestPath, adaptiveCardPath)
+                                        : "";
+                                    if (warning) {
+                                        warnings.push(warning);
+                                    }
+                                    commands.push(command);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return [commands, warnings];
+        });
+    }
+    static getRelativePath(from, to) {
+        const relativePath = path__default["default"].relative(path__default["default"].dirname(from), to);
+        return path__default["default"].normalize(relativePath).replace(/\\/g, "/");
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class AdaptiveCardGenerator {
+    static generateAdaptiveCard(operationItem) {
+        try {
+            const json = Utils.getResponseJson(operationItem);
+            let cardBody = [];
+            let schema = json.schema;
+            let jsonPath = "$";
+            if (schema && Object.keys(schema).length > 0) {
+                jsonPath = AdaptiveCardGenerator.getResponseJsonPathFromSchema(schema);
+                if (jsonPath !== "$") {
+                    schema = schema.properties[jsonPath];
+                }
+                cardBody = AdaptiveCardGenerator.generateCardFromResponse(schema, "");
+            }
+            // if no schema, try to use example value
+            if (cardBody.length === 0 && (json.examples || json.example)) {
+                cardBody = [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text: "${jsonStringify($root)}",
+                        wrap: true,
+                    },
+                ];
+            }
+            // if no example value, use default success response
+            if (cardBody.length === 0) {
+                cardBody = [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text: "success",
+                        wrap: true,
+                    },
+                ];
+            }
+            const fullCard = {
+                type: ConstantString.AdaptiveCardType,
+                $schema: ConstantString.AdaptiveCardSchema,
+                version: ConstantString.AdaptiveCardVersion,
+                body: cardBody,
+            };
+            return [fullCard, jsonPath];
+        }
+        catch (err) {
+            throw new SpecParserError(err.toString(), exports.ErrorType.GenerateAdaptiveCardFailed);
+        }
+    }
+    static generateCardFromResponse(schema, name, parentArrayName = "") {
+        if (schema.type === "array") {
+            // schema.items can be arbitrary object: schema { type: array, items: {} }
+            if (Object.keys(schema.items).length === 0) {
+                return [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text: name ? `${name}: \${jsonStringify(${name})}` : "result: ${jsonStringify($root)}",
+                        wrap: true,
+                    },
+                ];
+            }
+            const obj = AdaptiveCardGenerator.generateCardFromResponse(schema.items, "", name);
+            const template = {
+                type: ConstantString.ContainerType,
+                $data: name ? `\${${name}}` : "${$root}",
+                items: Array(),
+            };
+            template.items.push(...obj);
+            return [template];
+        }
+        // some schema may not contain type but contain properties
+        if (schema.type === "object" || (!schema.type && schema.properties)) {
+            const { properties } = schema;
+            const result = [];
+            for (const property in properties) {
+                const obj = AdaptiveCardGenerator.generateCardFromResponse(properties[property], name ? `${name}.${property}` : property, parentArrayName);
+                result.push(...obj);
+            }
+            if (schema.additionalProperties) {
+                // TODO: better ways to handler warnings.
+                console.warn(ConstantString.AdditionalPropertiesNotSupported);
+            }
+            return result;
+        }
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            if (!AdaptiveCardGenerator.isImageUrlProperty(schema, name, parentArrayName)) {
+                // string in root: "ddd"
+                let text = "result: ${$root}";
+                if (name) {
+                    // object { id: "1" }
+                    text = `${name}: \${if(${name}, ${name}, 'N/A')}`;
+                    if (parentArrayName) {
+                        // object types inside array: { tags: ["id": 1, "name": "name"] }
+                        text = `${parentArrayName}.${text}`;
+                    }
+                }
+                else if (parentArrayName) {
+                    // string array: photoUrls: ["1", "2"]
+                    text = `${parentArrayName}: ` + "${$data}";
+                }
+                return [
+                    {
+                        type: ConstantString.TextBlockType,
+                        text,
+                        wrap: true,
+                    },
+                ];
+            }
+            else {
+                if (name) {
+                    return [
+                        {
+                            type: "Image",
+                            url: `\${${name}}`,
+                            $when: `\${${name} != null}`,
+                        },
+                    ];
+                }
+                else {
+                    return [
+                        {
+                            type: "Image",
+                            url: "${$data}",
+                            $when: "${$data != null}",
+                        },
+                    ];
+                }
+            }
+        }
+        if (schema.oneOf || schema.anyOf || schema.not || schema.allOf) {
+            throw new Error(Utils.format(ConstantString.SchemaNotSupported, JSON.stringify(schema)));
+        }
+        throw new Error(Utils.format(ConstantString.UnknownSchema, JSON.stringify(schema)));
+    }
+    // Find the first array property in the response schema object with the well-known name
+    static getResponseJsonPathFromSchema(schema) {
+        if (schema.type === "object" || (!schema.type && schema.properties)) {
+            const { properties } = schema;
+            for (const property in properties) {
+                const schema = properties[property];
+                if (schema.type === "array" &&
+                    Utils.isWellKnownName(property, ConstantString.WellknownResultNames)) {
+                    return property;
+                }
+            }
+        }
+        return "$";
+    }
+    static isImageUrlProperty(schema, name, parentArrayName) {
+        const propertyName = name ? name : parentArrayName;
+        return (!!propertyName &&
+            schema.type === "string" &&
+            Utils.isWellKnownName(propertyName, ConstantString.WellknownImageName) &&
+            (propertyName.toLocaleLowerCase().indexOf("url") >= 0 || schema.format === "uri"));
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+function wrapAdaptiveCard(card, jsonPath) {
+    const result = {
+        version: ConstantString.WrappedCardVersion,
+        $schema: ConstantString.WrappedCardSchema,
+        jsonPath: jsonPath,
+        responseLayout: ConstantString.WrappedCardResponseLayout,
+        responseCardTemplate: card,
+        previewCardTemplate: inferPreviewCardTemplate(card),
+    };
+    return result;
+}
+/**
+ * Infers the preview card template from an Adaptive Card and a JSON path.
+ * The preview card template includes a title and an optional subtitle and image.
+ * It populates the preview card template with the first text block that matches
+ * each well-known name, in the order of title, subtitle, and image.
+ * If no text block matches the title or subtitle, it uses the first two text block as the title and subtitle.
+ * If the title is still empty and the subtitle is not empty, it uses subtitle as the title.
+ * @param card The Adaptive Card to infer the preview card template from.
+ * @param jsonPath The JSON path to the root object in the card body.
+ * @returns The inferred preview card template.
+ */
+function inferPreviewCardTemplate(card) {
+    var _a;
+    const result = {
+        title: "",
+    };
+    const textBlockElements = new Set();
+    let rootObject;
+    if (((_a = card.body[0]) === null || _a === void 0 ? void 0 : _a.type) === ConstantString.ContainerType) {
+        rootObject = card.body[0].items;
+    }
+    else {
+        rootObject = card.body;
+    }
+    for (const element of rootObject) {
+        if (element.type === ConstantString.TextBlockType) {
+            const textElement = element;
+            const index = textElement.text.indexOf("${if(");
+            if (index > 0) {
+                textElement.text = textElement.text.substring(index);
+                textBlockElements.add(textElement);
+            }
+        }
+    }
+    for (const element of textBlockElements) {
+        const text = element.text;
+        if (!result.title && Utils.isWellKnownName(text, ConstantString.WellknownTitleName)) {
+            result.title = text;
+            textBlockElements.delete(element);
+        }
+        else if (!result.subtitle && Utils.isWellKnownName(text, ConstantString.WellknownSubtitleName)) {
+            result.subtitle = text;
+            textBlockElements.delete(element);
+        }
+        else if (!result.image && Utils.isWellKnownName(text, ConstantString.WellknownImageName)) {
+            const match = text.match(/\${if\(([^,]+),/);
+            const property = match ? match[1] : "";
+            if (property) {
+                result.image = {
+                    url: `\${${property}}`,
+                    alt: text,
+                    $when: `\${${property} != null}`,
+                };
+            }
+            textBlockElements.delete(element);
+        }
+    }
+    for (const element of textBlockElements) {
+        const text = element.text;
+        if (!result.title) {
+            result.title = text;
+            textBlockElements.delete(element);
+        }
+        else if (!result.subtitle) {
+            result.subtitle = text;
+            textBlockElements.delete(element);
+        }
+    }
+    if (!result.title && result.subtitle) {
+        result.title = result.subtitle;
+        delete result.subtitle;
+    }
+    if (!result.title) {
+        result.title = "result";
+    }
+    return result;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * A class that parses an OpenAPI specification file and provides methods to validate, list, and generate artifacts.
+ */
+class SpecParser {
+    /**
+     * Creates a new instance of the SpecParser class.
+     * @param pathOrDoc The path to the OpenAPI specification file or the OpenAPI specification object.
+     * @param options The options for parsing the OpenAPI specification file.
+     */
+    constructor(pathOrDoc, options) {
+        this.defaultOptions = {
+            allowMissingId: true,
+            allowSwagger: true,
+            allowAPIKeyAuth: false,
+            allowMultipleParameters: false,
+            allowOauth2: false,
+        };
+        this.pathOrSpec = pathOrDoc;
+        this.parser = new SwaggerParser__default["default"]();
+        this.options = Object.assign(Object.assign({}, this.defaultOptions), (options !== null && options !== void 0 ? options : {}));
+    }
+    /**
+     * Validates the OpenAPI specification file and returns a validation result.
+     *
+     * @returns A validation result object that contains information about any errors or warnings in the specification file.
+     */
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                try {
+                    yield this.loadSpec();
+                    yield this.parser.validate(this.spec);
+                }
+                catch (e) {
+                    return {
+                        status: exports.ValidationStatus.Error,
+                        warnings: [],
+                        errors: [{ type: exports.ErrorType.SpecNotValid, content: e.toString() }],
+                    };
+                }
+                if (!this.options.allowSwagger && this.isSwaggerFile) {
+                    return {
+                        status: exports.ValidationStatus.Error,
+                        warnings: [],
+                        errors: [
+                            { type: exports.ErrorType.SwaggerNotSupported, content: ConstantString.SwaggerNotSupported },
+                        ],
+                    };
+                }
+                return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+            }
+            catch (err) {
+                throw new SpecParserError(err.toString(), exports.ErrorType.ValidateFailed);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    listSupportedAPIInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Method not implemented.");
+        });
+    }
+    /**
+     * Lists all the OpenAPI operations in the specification file.
+     * @returns A string array that represents the HTTP method and path of each operation, such as ['GET /pets/{petId}', 'GET /user/{userId}']
+     * according to copilot plugin spec, only list get and post method without auth
+     */
+    list() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.loadSpec();
+                const spec = this.spec;
+                const apiMap = this.getAllSupportedAPIs(spec);
+                const result = [];
+                for (const apiKey in apiMap) {
+                    const apiResult = {
+                        api: "",
+                        server: "",
+                        operationId: "",
+                    };
+                    const [method, path] = apiKey.split(" ");
+                    const operation = apiMap[apiKey];
+                    const rootServer = spec.servers && spec.servers[0];
+                    const methodServer = spec.paths[path].servers && ((_a = spec.paths[path]) === null || _a === void 0 ? void 0 : _a.servers[0]);
+                    const operationServer = operation.servers && operation.servers[0];
+                    const serverUrl = operationServer || methodServer || rootServer;
+                    if (!serverUrl) {
+                        throw new SpecParserError(ConstantString.NoServerInformation, exports.ErrorType.NoServerInformation);
+                    }
+                    apiResult.server = Utils.resolveServerUrl(serverUrl.url);
+                    let operationId = operation.operationId;
+                    if (!operationId) {
+                        operationId = `${method.toLowerCase()}${Utils.convertPathToCamelCase(path)}`;
+                    }
+                    apiResult.operationId = operationId;
+                    const authArray = Utils.getAuthArray(operation.security, spec);
+                    for (const auths of authArray) {
+                        if (auths.length === 1) {
+                            apiResult.auth = auths[0].authSchema;
+                            break;
+                        }
+                    }
+                    apiResult.api = apiKey;
+                    result.push(apiResult);
+                }
+                return result;
+            }
+            catch (err) {
+                if (err instanceof SpecParserError) {
+                    throw err;
+                }
+                throw new SpecParserError(err.toString(), exports.ErrorType.ListFailed);
+            }
+        });
+    }
+    /**
+     * Generates and update artifacts from the OpenAPI specification file. Generate Adaptive Cards, update Teams app manifest, and generate a new OpenAPI specification file.
+     * @param manifestPath A file path of the Teams app manifest file to update.
+     * @param filter An array of strings that represent the filters to apply when generating the artifacts. If filter is empty, it would process nothing.
+     * @param outputSpecPath File path of the new OpenAPI specification file to generate. If not specified or empty, no spec file will be generated.
+     * @param adaptiveCardFolder Folder path where the Adaptive Card files will be generated. If not specified or empty, Adaptive Card files will not be generated.
+     */
+    generate(manifestPath, filter, outputSpecPath, adaptiveCardFolder, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {
+                allSuccess: true,
+                warnings: [],
+            };
+            try {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
+                }
+                yield this.loadSpec();
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
+                }
+                const newUnResolvedSpec = SpecFilter.specFilter(filter, this.unResolveSpec, this.spec, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
+                }
+                const newSpec = (yield this.parser.dereference(newUnResolvedSpec));
+                const AuthSet = new Set();
+                let hasMultipleAPIKeyAuth = false;
+                for (const url in newSpec.paths) {
+                    for (const method in newSpec.paths[url]) {
+                        const operation = newSpec.paths[url][method];
+                        const authArray = Utils.getAuthArray(operation.security, newSpec);
+                        if (authArray && authArray.length > 0) {
+                            AuthSet.add(authArray[0][0].authSchema);
+                            if (AuthSet.size > 1) {
+                                hasMultipleAPIKeyAuth = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (hasMultipleAPIKeyAuth) {
+                    throw new SpecParserError(ConstantString.MultipleAPIKeyNotSupported, exports.ErrorType.MultipleAPIKeyNotSupported);
+                }
+                let resultStr;
+                if (outputSpecPath.endsWith(".yaml") || outputSpecPath.endsWith(".yml")) {
+                    resultStr = jsyaml__default["default"].dump(newUnResolvedSpec);
+                }
+                else {
+                    resultStr = JSON.stringify(newUnResolvedSpec, null, 2);
+                }
+                yield fs__default["default"].outputFile(outputSpecPath, resultStr);
+                for (const url in newSpec.paths) {
+                    for (const method in newSpec.paths[url]) {
+                        // paths object may contain description/summary, so we need to check if it is a operation object
+                        if (method === ConstantString.PostMethod || method === ConstantString.GetMethod) {
+                            const operation = newSpec.paths[url][method];
+                            try {
+                                const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operation);
+                                const fileName = path__default["default"].join(adaptiveCardFolder, `${operation.operationId}.json`);
+                                const wrappedCard = wrapAdaptiveCard(card, jsonPath);
+                                yield fs__default["default"].outputJSON(fileName, wrappedCard, { spaces: 2 });
+                                const dataFileName = path__default["default"].join(adaptiveCardFolder, `${operation.operationId}.data.json`);
+                                yield fs__default["default"].outputJSON(dataFileName, {}, { spaces: 2 });
+                            }
+                            catch (err) {
+                                result.allSuccess = false;
+                                result.warnings.push({
+                                    type: exports.WarningType.GenerateCardFailed,
+                                    content: err.toString(),
+                                    data: operation.operationId,
+                                });
+                            }
+                        }
+                    }
+                }
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
+                }
+                const auth = Array.from(AuthSet)[0];
+                const [updatedManifest, warnings] = yield ManifestUpdater.updateManifest(manifestPath, outputSpecPath, adaptiveCardFolder, newSpec, this.options.allowMultipleParameters, auth);
+                yield fs__default["default"].outputJSON(manifestPath, updatedManifest, { spaces: 2 });
+                result.warnings.push(...warnings);
+            }
+            catch (err) {
+                if (err instanceof SpecParserError) {
+                    throw err;
+                }
+                throw new SpecParserError(err.toString(), exports.ErrorType.GenerateFailed);
+            }
+            return result;
+        });
+    }
+    loadSpec() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.spec) {
+                this.unResolveSpec = (yield this.parser.parse(this.pathOrSpec));
+                // Convert swagger 2.0 to openapi 3.0
+                if (!this.unResolveSpec.openapi && this.unResolveSpec.swagger === "2.0") {
+                    const specObj = yield converter__default["default"].convert(this.unResolveSpec, {});
+                    this.unResolveSpec = specObj.openapi;
+                    this.isSwaggerFile = true;
+                }
+                const clonedUnResolveSpec = JSON.parse(JSON.stringify(this.unResolveSpec));
+                this.spec = (yield this.parser.dereference(clonedUnResolveSpec));
+            }
+        });
+    }
+    getAllSupportedAPIs(spec) {
+        if (this.apiMap !== undefined) {
+            return this.apiMap;
+        }
+        const result = Utils.listSupportedAPIs(spec, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+        this.apiMap = result;
+        return result;
+    }
+}
+
+exports.ConstantString = ConstantString;
+exports.SpecParser = SpecParser;
+exports.SpecParserError = SpecParserError;
+//# sourceMappingURL=index.node.cjs.js.map