@microsoft/m365-spec-parser 0.1.1-alpha.78701ec6a.0 → 0.1.1-alpha.7fe3da414.0

package/dist/index.esm2017.js

@@ -15,7 +15,8 @@ var ErrorType;
     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["MultipleAuthNotSupported"] = "multiple-auth-not-supported";
+    ErrorType["SpecVersionNotSupported"] = "spec-version-not-supported";
     ErrorType["ListFailed"] = "list-failed";
     ErrorType["listSupportedAPIInfoFailed"] = "list-supported-api-info-failed";
     ErrorType["FilterSpecFailed"] = "filter-spec-failed";
@@ -23,6 +24,22 @@ var ErrorType;
     ErrorType["GenerateAdaptiveCardFailed"] = "generate-adaptive-card-failed";
     ErrorType["GenerateFailed"] = "generate-failed";
     ErrorType["ValidateFailed"] = "validate-failed";
+    ErrorType["GetSpecFailed"] = "get-spec-failed";
+    ErrorType["AuthTypeIsNotSupported"] = "auth-type-is-not-supported";
+    ErrorType["MissingOperationId"] = "missing-operation-id";
+    ErrorType["PostBodyContainMultipleMediaTypes"] = "post-body-contain-multiple-media-types";
+    ErrorType["ResponseContainMultipleMediaTypes"] = "response-contain-multiple-media-types";
+    ErrorType["ResponseJsonIsEmpty"] = "response-json-is-empty";
+    ErrorType["PostBodySchemaIsNotJson"] = "post-body-schema-is-not-json";
+    ErrorType["PostBodyContainsRequiredUnsupportedSchema"] = "post-body-contains-required-unsupported-schema";
+    ErrorType["ParamsContainRequiredUnsupportedSchema"] = "params-contain-required-unsupported-schema";
+    ErrorType["ParamsContainsNestedObject"] = "params-contains-nested-object";
+    ErrorType["RequestBodyContainsNestedObject"] = "request-body-contains-nested-object";
+    ErrorType["ExceededRequiredParamsLimit"] = "exceeded-required-params-limit";
+    ErrorType["NoParameter"] = "no-parameter";
+    ErrorType["NoAPIInfo"] = "no-api-info";
+    ErrorType["MethodNotAllowed"] = "method-not-allowed";
+    ErrorType["UrlPathNotExist"] = "url-path-not-exist";
     ErrorType["Cancelled"] = "cancelled";
     ErrorType["Unknown"] = "unknown";
 })(ErrorType || (ErrorType = {}));
@@ -45,7 +62,13 @@ var ValidationStatus;
     ValidationStatus[ValidationStatus["Valid"] = 0] = "Valid";
     ValidationStatus[ValidationStatus["Warning"] = 1] = "Warning";
     ValidationStatus[ValidationStatus["Error"] = 2] = "Error";
-})(ValidationStatus || (ValidationStatus = {}));
+})(ValidationStatus || (ValidationStatus = {}));
+var ProjectType;
+(function (ProjectType) {
+    ProjectType[ProjectType["Copilot"] = 0] = "Copilot";
+    ProjectType[ProjectType["SME"] = 1] = "SME";
+    ProjectType[ProjectType["TeamsAi"] = 2] = "TeamsAi";
+})(ProjectType || (ProjectType = {}));
 
 // Copyright (c) Microsoft Corporation.
 class SpecParserError extends Error {
@@ -72,7 +95,9 @@ ConstantString.ResolveServerUrlFailed = "Unable to resolve the server URL: pleas
 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.SpecVersionNotSupported = "Unsupported OpenAPI version %s. Please use version 3.0.x.";
+ConstantString.MultipleAuthNotSupported = "Multiple authentication methods are unsupported. Ensure all selected APIs use identical authentication.";
+ConstantString.UnsupportedSchema = "Unsupported schema in %s %s: %s";
 ConstantString.WrappedCardVersion = "devPreview";
 ConstantString.WrappedCardSchema = "https://developer.microsoft.com/json-schemas/teams/vDevPreview/MicrosoftTeams.ResponseRenderingTemplate.schema.json";
 ConstantString.WrappedCardResponseLayout = "list";
@@ -84,6 +109,7 @@ ConstantString.AdaptiveCardType = "AdaptiveCard";
 ConstantString.TextBlockType = "TextBlock";
 ConstantString.ContainerType = "Container";
 ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
+ConstantString.OAuthRegistrationIdPostFix = "OAUTH_REGISTRATION_ID";
 ConstantString.ResponseCodeFor20X = [
     "200",
     "201",
@@ -143,15 +169,28 @@ ConstantString.FullDescriptionMaxLens = 4000;
 ConstantString.CommandDescriptionMaxLens = 128;
 ConstantString.ParameterDescriptionMaxLens = 128;
 ConstantString.CommandTitleMaxLens = 32;
-ConstantString.ParameterTitleMaxLens = 32;
+ConstantString.ParameterTitleMaxLens = 32;
+ConstantString.SMERequiredParamsMaxNum = 5;
 
 // Copyright (c) Microsoft Corporation.
 class Utils {
-    static checkParameters(paramObject) {
+    static hasNestedObjectInSchema(schema) {
+        if (schema.type === "object") {
+            for (const property in schema.properties) {
+                const nestedSchema = schema.properties[property];
+                if (nestedSchema.type === "object") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static checkParameters(paramObject, isCopilot) {
         const paramResult = {
             requiredNum: 0,
             optionalNum: 0,
             isValid: true,
+            reason: [],
         };
         if (!paramObject) {
             return paramResult;
@@ -159,10 +198,25 @@ class Utils {
         for (let i = 0; i < paramObject.length; i++) {
             const param = paramObject[i];
             const schema = param.schema;
+            if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+                paramResult.isValid = false;
+                paramResult.reason.push(ErrorType.ParamsContainsNestedObject);
+                continue;
+            }
             const isRequiredWithoutDefault = param.required && schema.default === undefined;
+            if (isCopilot) {
+                if (isRequiredWithoutDefault) {
+                    paramResult.requiredNum = paramResult.requiredNum + 1;
+                }
+                else {
+                    paramResult.optionalNum = paramResult.optionalNum + 1;
+                }
+                continue;
+            }
             if (param.in === "header" || param.in === "cookie") {
                 if (isRequiredWithoutDefault) {
                     paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
                 }
                 continue;
             }
@@ -172,6 +226,7 @@ class Utils {
                 schema.type !== "integer") {
                 if (isRequiredWithoutDefault) {
                     paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
                 }
                 continue;
             }
@@ -186,17 +241,23 @@ class Utils {
         }
         return paramResult;
     }
-    static checkPostBody(schema, isRequired = false) {
+    static checkPostBody(schema, isRequired = false, isCopilot = false) {
         var _a;
         const paramResult = {
             requiredNum: 0,
             optionalNum: 0,
             isValid: true,
+            reason: [],
         };
         if (Object.keys(schema).length === 0) {
             return paramResult;
         }
         const isRequiredWithoutDefault = isRequired && schema.default === undefined;
+        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+            paramResult.isValid = false;
+            paramResult.reason = [ErrorType.RequestBodyContainsNestedObject];
+            return paramResult;
+        }
         if (schema.type === "string" ||
             schema.type === "integer" ||
             schema.type === "boolean" ||
@@ -215,19 +276,24 @@ class Utils {
                 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);
+                const result = Utils.checkPostBody(properties[property], isRequired, isCopilot);
                 paramResult.requiredNum += result.requiredNum;
                 paramResult.optionalNum += result.optionalNum;
                 paramResult.isValid = paramResult.isValid && result.isValid;
+                paramResult.reason.push(...result.reason);
             }
         }
         else {
-            if (isRequiredWithoutDefault) {
+            if (isRequiredWithoutDefault && !isCopilot) {
                 paramResult.isValid = false;
+                paramResult.reason.push(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
             }
         }
         return paramResult;
     }
+    static containMultipleMediaTypes(bodyObject) {
+        return Object.keys((bodyObject === null || bodyObject === void 0 ? void 0 : bodyObject.content) || {}).length > 1;
+    }
     /**
      * Checks if the given API is supported.
      * @param {string} method - The HTTP method of the API.
@@ -242,106 +308,137 @@ class Utils {
      * 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];
+    static isSupportedApi(method, path, spec, options) {
+        var _a;
+        const result = { isValid: true, reason: [] };
         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;
+        if (options.allowMethods && !options.allowMethods.includes(method)) {
+            result.isValid = false;
+            result.reason.push(ErrorType.MethodNotAllowed);
+            return result;
+        }
+        const pathObj = spec.paths[path];
+        if (!pathObj || !pathObj[method]) {
+            result.isValid = false;
+            result.reason.push(ErrorType.UrlPathNotExist);
+            return result;
+        }
+        const securities = pathObj[method].security;
+        const isTeamsAi = options.projectType === ProjectType.TeamsAi;
+        const isCopilot = options.projectType === ProjectType.Copilot;
+        // Teams AI project doesn't care about auth, it will use authProvider for user to implement
+        if (!isTeamsAi) {
+            const authArray = Utils.getAuthArray(securities, spec);
+            const authCheckResult = Utils.isSupportedAuth(authArray, options);
+            if (!authCheckResult.isValid) {
+                result.reason.push(...authCheckResult.reason);
+            }
+        }
+        const operationObject = pathObj[method];
+        if (!options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        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 = operationObject.servers && operationObject.servers[0];
+        const serverUrl = operationServer || methodServer || rootServer;
+        if (!serverUrl) {
+            result.reason.push(ErrorType.NoServerInformation);
+        }
+        else {
+            const serverValidateResult = Utils.checkServerUrl([serverUrl]);
+            result.reason.push(...serverValidateResult.map((item) => item.type));
+        }
+        const paramObject = operationObject.parameters;
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (!isTeamsAi && Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        const { json, multipleMediaType } = Utils.getResponseJson(operationObject, isTeamsAi);
+        if (multipleMediaType && !isTeamsAi) {
+            result.reason.push(ErrorType.ResponseContainMultipleMediaTypes);
+        }
+        else if (Object.keys(json).length === 0) {
+            result.reason.push(ErrorType.ResponseJsonIsEmpty);
+        }
+        // Teams AI project doesn't care about request parameters/body
+        if (!isTeamsAi) {
+            let requestBodyParamResult = {
+                requiredNum: 0,
+                optionalNum: 0,
+                isValid: true,
+                reason: [],
+            };
+            if (requestJsonBody) {
+                const requestBodySchema = requestJsonBody.schema;
+                if (isCopilot && requestBodySchema.type !== "object") {
+                    result.reason.push(ErrorType.PostBodySchemaIsNotJson);
                 }
-                const paramResult = Utils.checkParameters(paramObject);
-                if (!paramResult.isValid) {
-                    return false;
+                requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required, isCopilot);
+                if (!requestBodyParamResult.isValid && requestBodyParamResult.reason) {
+                    result.reason.push(...requestBodyParamResult.reason);
                 }
-                if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
-                    if (allowMultipleParameters &&
-                        requestBodyParamResult.requiredNum + paramResult.requiredNum <= 5) {
-                        return true;
+            }
+            const paramResult = Utils.checkParameters(paramObject, isCopilot);
+            if (!paramResult.isValid && paramResult.reason) {
+                result.reason.push(...paramResult.reason);
+            }
+            // Copilot support arbitrary parameters
+            if (!isCopilot && paramResult.isValid && requestBodyParamResult.isValid) {
+                const totalRequiredParams = requestBodyParamResult.requiredNum + paramResult.requiredNum;
+                const totalParams = totalRequiredParams + requestBodyParamResult.optionalNum + paramResult.optionalNum;
+                if (totalRequiredParams > 1) {
+                    if (!options.allowMultipleParameters ||
+                        totalRequiredParams > ConstantString.SMERequiredParamsMaxNum) {
+                        result.reason.push(ErrorType.ExceededRequiredParamsLimit);
                     }
-                    return false;
                 }
-                else if (requestBodyParamResult.requiredNum +
-                    requestBodyParamResult.optionalNum +
-                    paramResult.requiredNum +
-                    paramResult.optionalNum ===
-                    0) {
-                    return false;
-                }
-                else {
-                    return true;
+                else if (totalParams === 0) {
+                    result.reason.push(ErrorType.NoParameter);
                 }
             }
         }
-        return false;
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
     }
-    static isSupportedAuth(authSchemaArray, allowAPIKeyAuth, allowOauth2) {
-        if (authSchemaArray.length === 0) {
-            return true;
+    static isSupportedAuth(authSchemeArray, options) {
+        if (authSchemeArray.length === 0) {
+            return { isValid: true, reason: [] };
         }
-        if (allowAPIKeyAuth || allowOauth2) {
+        if (options.allowAPIKeyAuth || options.allowOauth2 || options.allowBearerTokenAuth) {
             // Currently we don't support multiple auth in one operation
-            if (authSchemaArray.length > 0 && authSchemaArray.every((auths) => auths.length > 1)) {
-                return false;
+            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
+                return {
+                    isValid: false,
+                    reason: [ErrorType.MultipleAuthNotSupported],
+                };
             }
-            for (const auths of authSchemaArray) {
+            for (const auths of authSchemeArray) {
                 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;
+                    if ((options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
+                        (options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
+                        (options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
+                        return { isValid: true, reason: [] };
                     }
                 }
             }
         }
-        return false;
+        return { isValid: false, reason: [ErrorType.AuthTypeIsNotSupported] };
     }
-    static isAPIKeyAuth(authSchema) {
-        return authSchema.type === "apiKey";
+    static isBearerTokenAuth(authScheme) {
+        return authScheme.type === "http" && authScheme.scheme === "bearer";
     }
-    static isBearerTokenAuth(authSchema) {
-        return (authSchema.type === "oauth2" ||
-            authSchema.type === "openIdConnect" ||
-            (authSchema.type === "http" && authSchema.scheme === "bearer"));
+    static isAPIKeyAuth(authScheme) {
+        return authScheme.type === "apiKey";
+    }
+    static isOAuthWithAuthCodeFlow(authScheme) {
+        if (authScheme.type === "oauth2" && authScheme.flows && authScheme.flows.authorizationCode) {
+            return true;
+        }
+        return false;
     }
     static getAuthArray(securities, spec) {
         var _a;
@@ -354,7 +451,7 @@ class Utils {
                 for (const name in security) {
                     const auth = securitySchemas[name];
                     authArray.push({
-                        authSchema: auth,
+                        authScheme: auth,
                         name: name,
                     });
                 }
@@ -369,21 +466,28 @@ class Utils {
     static updateFirstLetter(str) {
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
-    static getResponseJson(operationObject) {
+    static getResponseJson(operationObject, isTeamsAiProject = false) {
         var _a, _b;
         let json = {};
+        let multipleMediaType = false;
         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"]) {
+                multipleMediaType = false;
                 json = responseObject.content["application/json"];
-                break;
+                if (Utils.containMultipleMediaTypes(responseObject)) {
+                    multipleMediaType = true;
+                    if (isTeamsAiProject) {
+                        break;
+                    }
+                    json = {};
+                }
+                else {
+                    break;
+                }
             }
         }
-        return json;
+        return { json, multipleMediaType };
     }
     static convertPathToCamelCase(path) {
         const pathSegments = path.split(/[./{]/);
@@ -403,10 +507,10 @@ class Utils {
             return undefined;
         }
     }
-    static resolveServerUrl(url) {
+    static resolveEnv(str) {
         const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
-        let matches = placeHolderReg.exec(url);
-        let newUrl = url;
+        let matches = placeHolderReg.exec(str);
+        let newStr = str;
         while (matches != null) {
             const envVar = matches[1];
             const envVal = process.env[envVar];
@@ -414,17 +518,17 @@ class Utils {
                 throw new Error(Utils.format(ConstantString.ResolveServerUrlFailed, envVar));
             }
             else {
-                newUrl = newUrl.replace(matches[0], envVal);
+                newStr = newStr.replace(matches[0], envVal);
             }
-            matches = placeHolderReg.exec(url);
+            matches = placeHolderReg.exec(str);
         }
-        return newUrl;
+        return newStr;
     }
     static checkServerUrl(servers) {
         const errors = [];
         let serverUrl;
         try {
-            serverUrl = Utils.resolveServerUrl(servers[0].url);
+            serverUrl = Utils.resolveEnv(servers[0].url);
         }
         catch (err) {
             errors.push({
@@ -454,7 +558,8 @@ class Utils {
         }
         return errors;
     }
-    static validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+    static validateServer(spec, options) {
+        var _a;
         const errors = [];
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
@@ -475,7 +580,7 @@ class Utils {
             }
             for (const method in methods) {
                 const operationObject = methods[method];
-                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2)) {
+                if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
                     if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
                         hasOperationLevelServers = true;
                         const serverErrors = Utils.checkServerUrl(operationObject.servers);
@@ -518,6 +623,7 @@ class Utils {
                 Utils.updateParameterWithInputType(schema, parameter);
             }
             if (isRequired && schema.default === undefined) {
+                parameter.isRequired = true;
                 requiredParams.push(parameter);
             }
             else {
@@ -562,7 +668,7 @@ class Utils {
             param.value = schema.default;
         }
     }
-    static parseApiInfo(operationItem, allowMultipleParameters) {
+    static parseApiInfo(operationItem, options) {
         var _a, _b;
         const requiredParams = [];
         const optionalParams = [];
@@ -576,11 +682,12 @@ class Utils {
                     description: ((_a = param.description) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.ParameterDescriptionMaxLens),
                 };
                 const schema = param.schema;
-                if (allowMultipleParameters && schema) {
+                if (options.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) {
+                        parameter.isRequired = true;
                         requiredParams.push(parameter);
                     }
                     else {
@@ -594,7 +701,7 @@ class Utils {
             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);
+                const [requiredP, optionalP] = Utils.generateParametersFromSchema(schema, "requestBody", !!options.allowMultipleParameters, requestBody.required);
                 requiredParams.push(...requiredP);
                 optionalParams.push(...optionalP);
             }
@@ -625,32 +732,37 @@ class Utils {
         }
         return [command, warning];
     }
-    static listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+    static listAPIs(spec, options) {
+        var _a;
         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;
+                const operationObject = methods[method];
+                if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
+                    const validateResult = Utils.isSupportedApi(method, path, spec, options);
+                    result[`${method.toUpperCase()} ${path}`] = {
+                        operation: operationObject,
+                        isValid: validateResult.isValid,
+                        reason: validateResult.reason,
+                    };
                 }
             }
         }
         return result;
     }
-    static validateSpec(spec, parser, isSwaggerFile, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+    static validateSpec(spec, parser, isSwaggerFile, options) {
         const errors = [];
         const warnings = [];
+        const apiMap = Utils.listAPIs(spec, options);
         if (isSwaggerFile) {
             warnings.push({
                 type: WarningType.ConvertSwaggerToOpenAPI,
                 content: ConstantString.ConvertSwaggerToOpenAPI,
             });
         }
-        // Server validation
-        const serverErrors = Utils.validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2);
+        const serverErrors = Utils.validateServer(spec, options);
         errors.push(...serverErrors);
         // Remote reference not supported
         const refPaths = parser.$refs.paths();
@@ -663,8 +775,8 @@ class Utils {
             });
         }
         // No supported API
-        const apiMap = Utils.listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2);
-        if (Object.keys(apiMap).length === 0) {
+        const validAPIs = Object.entries(apiMap).filter(([, value]) => value.isValid);
+        if (validAPIs.length === 0) {
             errors.push({
                 type: ErrorType.NoSupportedApi,
                 content: ConstantString.NoSupportedApi,
@@ -673,8 +785,8 @@ class Utils {
         // OperationId missing
         const apisMissingOperationId = [];
         for (const key in apiMap) {
-            const pathObjectItem = apiMap[key];
-            if (!pathObjectItem.operationId) {
+            const { operation } = apiMap[key];
+            if (!operation.operationId) {
                 apisMissingOperationId.push(key);
             }
         }
@@ -715,6 +827,19 @@ class Utils {
         }
         return safeRegistrationIdEnvName;
     }
+    static getAllAPICount(spec) {
+        let count = 0;
+        const paths = spec.paths;
+        for (const path in paths) {
+            const methods = paths[path];
+            for (const method in methods) {
+                if (ConstantString.AllOperationMethods.includes(method)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -733,7 +858,10 @@ class SpecParser {
             allowSwagger: false,
             allowAPIKeyAuth: false,
             allowMultipleParameters: false,
+            allowBearerTokenAuth: false,
             allowOauth2: false,
+            allowMethods: ["get", "post"],
+            projectType: ProjectType.SME,
         };
         this.pathOrSpec = pathOrDoc;
         this.parser = new SwaggerParser();
@@ -770,7 +898,7 @@ class SpecParser {
                     ],
                 };
             }
-            return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+            return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options);
         }
         catch (err) {
             throw new SpecParserError(err.toString(), ErrorType.ValidateFailed);
@@ -789,7 +917,7 @@ class SpecParser {
                 if (!operationId) {
                     continue;
                 }
-                const [command, warning] = Utils.parseApiInfo(pathObjectItem, this.options.allowMultipleParameters);
+                const [command, warning] = Utils.parseApiInfo(pathObjectItem, this.options);
                 const apiInfo = {
                     method: method,
                     path: path,
@@ -818,12 +946,32 @@ class SpecParser {
     async list() {
         throw new Error("Method not implemented.");
     }
+    /**
+     * Generate specs according to the filters.
+     * @param filter An array of strings that represent the filters to apply when generating the artifacts. If filter is empty, it would process nothing.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getFilteredSpecs(filter, signal) {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * 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 pluginFilePath File path of the api plugin file to generate.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async generateForCopilot(manifestPath, filter, outputSpecPath, pluginFilePath, signal) {
+        throw new Error("Method not implemented.");
+    }
     /**
      * 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.
+     * @param isMe Boolean that indicates whether the project is an Messaging Extension. For Messaging Extension, composeExtensions will be added in Teams app manifest.
      */
     // eslint-disable-next-line @typescript-eslint/require-await
     async generate(manifestPath, filter, outputSpecPath, adaptiveCardFolder, signal) {
@@ -843,11 +991,187 @@ class SpecParser {
         if (this.apiMap !== undefined) {
             return this.apiMap;
         }
-        const result = Utils.listSupportedAPIs(spec, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+        const result = this.listSupportedAPIs(spec, this.options);
         this.apiMap = result;
         return result;
     }
+    listSupportedAPIs(spec, options) {
+        var _a;
+        const paths = spec.paths;
+        const result = {};
+        for (const path in paths) {
+            const methods = paths[path];
+            for (const method in methods) {
+                const operationObject = methods[method];
+                if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
+                    const validateResult = Utils.isSupportedApi(method, path, spec, options);
+                    if (validateResult.isValid) {
+                        result[`${method.toUpperCase()} ${path}`] = operationObject;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+
+// 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(), 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"));
+    }
 }
 
-export { ConstantString, ErrorType, SpecParser, SpecParserError, Utils, ValidationStatus, WarningType };
+export { AdaptiveCardGenerator, ConstantString, ErrorType, SpecParser, SpecParserError, Utils, ValidationStatus, WarningType };
 //# sourceMappingURL=index.esm2017.js.map