@microsoft/m365-spec-parser 0.1.1-alpha.54a90c74e.0 → 0.1.1-alpha.6341e718e.0

package/dist/index.esm2017.js

@@ -25,6 +25,21 @@ var ErrorType;
     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 = {}));
@@ -170,221 +185,9 @@ class Utils {
         }
         return false;
     }
-    static checkParameters(paramObject, isCopilot) {
-        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;
-            if (isCopilot && this.hasNestedObjectInSchema(schema)) {
-                paramResult.isValid = false;
-                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;
-                }
-                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, isCopilot = 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 (isCopilot && this.hasNestedObjectInSchema(schema)) {
-            paramResult.isValid = false;
-            return paramResult;
-        }
-        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, isCopilot);
-                paramResult.requiredNum += result.requiredNum;
-                paramResult.optionalNum += result.optionalNum;
-                paramResult.isValid = paramResult.isValid && result.isValid;
-            }
-        }
-        else {
-            if (isRequiredWithoutDefault && !isCopilot) {
-                paramResult.isValid = false;
-            }
-        }
-        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.
-     * @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, options) {
-        var _a;
-        const pathObj = spec.paths[path];
-        method = method.toLocaleLowerCase();
-        if (pathObj) {
-            if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && pathObj[method]) {
-                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);
-                    if (!Utils.isSupportedAuth(authArray, options)) {
-                        return false;
-                    }
-                }
-                const operationObject = pathObj[method];
-                if (!options.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"];
-                if (!isTeamsAi && Utils.containMultipleMediaTypes(requestBody)) {
-                    return false;
-                }
-                const responseJson = Utils.getResponseJson(operationObject, isTeamsAi);
-                if (Object.keys(responseJson).length === 0) {
-                    return false;
-                }
-                // Teams AI project doesn't care about request parameters/body
-                if (isTeamsAi) {
-                    return true;
-                }
-                let requestBodyParamResult = {
-                    requiredNum: 0,
-                    optionalNum: 0,
-                    isValid: true,
-                };
-                if (requestJsonBody) {
-                    const requestBodySchema = requestJsonBody.schema;
-                    if (isCopilot && requestBodySchema.type !== "object") {
-                        return false;
-                    }
-                    requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required, isCopilot);
-                }
-                if (!requestBodyParamResult.isValid) {
-                    return false;
-                }
-                const paramResult = Utils.checkParameters(paramObject, isCopilot);
-                if (!paramResult.isValid) {
-                    return false;
-                }
-                // Copilot support arbitrary parameters
-                if (isCopilot) {
-                    return true;
-                }
-                if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
-                    if (options.allowMultipleParameters &&
-                        requestBodyParamResult.requiredNum + paramResult.requiredNum <=
-                            ConstantString.SMERequiredParamsMaxNum) {
-                        return true;
-                    }
-                    return false;
-                }
-                else if (requestBodyParamResult.requiredNum +
-                    requestBodyParamResult.optionalNum +
-                    paramResult.requiredNum +
-                    paramResult.optionalNum ===
-                    0) {
-                    return false;
-                }
-                else {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    static isSupportedAuth(authSchemeArray, options) {
-        if (authSchemeArray.length === 0) {
-            return true;
-        }
-        if (options.allowAPIKeyAuth || options.allowOauth2 || options.allowBearerTokenAuth) {
-            // Currently we don't support multiple auth in one operation
-            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
-                return false;
-            }
-            for (const auths of authSchemeArray) {
-                if (auths.length === 1) {
-                    if ((options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
-                        (options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
-                        (options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
     static isBearerTokenAuth(authScheme) {
         return authScheme.type === "http" && authScheme.scheme === "bearer";
     }
@@ -392,10 +195,9 @@ class Utils {
         return authScheme.type === "apiKey";
     }
     static isOAuthWithAuthCodeFlow(authScheme) {
-        if (authScheme.type === "oauth2" && authScheme.flows && authScheme.flows.authorizationCode) {
-            return true;
-        }
-        return false;
+        return !!(authScheme.type === "oauth2" &&
+            authScheme.flows &&
+            authScheme.flows.authorizationCode);
     }
     static getAuthArray(securities, spec) {
         var _a;
@@ -423,14 +225,17 @@ class Utils {
     static updateFirstLetter(str) {
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
-    static getResponseJson(operationObject, isTeamsAiProject = false) {
+    static getResponseJson(operationObject) {
         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];
             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"];
-                if (!isTeamsAiProject && Utils.containMultipleMediaTypes(responseObject)) {
+                if (Utils.containMultipleMediaTypes(responseObject)) {
+                    multipleMediaType = true;
                     json = {};
                 }
                 else {
@@ -438,7 +243,7 @@ class Utils {
                 }
             }
         }
-        return json;
+        return { json, multipleMediaType };
     }
     static convertPathToCamelCase(path) {
         const pathSegments = path.split(/[./{]/);
@@ -458,10 +263,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];
@@ -469,17 +274,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({
@@ -510,6 +315,7 @@ class Utils {
         return errors;
     }
     static validateServer(spec, options) {
+        var _a;
         const errors = [];
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
@@ -530,7 +336,7 @@ class Utils {
             }
             for (const method in methods) {
                 const operationObject = methods[method];
-                if (Utils.isSupportedApi(method, path, spec, options)) {
+                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);
@@ -657,13 +463,7 @@ class Utils {
             }
         }
         const operationId = operationItem.operationId;
-        const parameters = [];
-        if (requiredParams.length !== 0) {
-            parameters.push(...requiredParams);
-        }
-        else {
-            parameters.push(optionalParams[0]);
-        }
+        const parameters = [...requiredParams, ...optionalParams];
         const command = {
             context: ["compose"],
             type: "query",
@@ -672,31 +472,9 @@ class Utils {
             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: WarningType.OperationOnlyContainsOptionalParam,
-                content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, operationId),
-                data: operationId,
-            };
-        }
-        return [command, warning];
-    }
-    static listSupportedAPIs(spec, options) {
-        const paths = spec.paths;
-        const result = {};
-        for (const path in paths) {
-            const methods = paths[path];
-            for (const method in methods) {
-                if (Utils.isSupportedApi(method, path, spec, options)) {
-                    const operationObject = methods[method];
-                    result[`${method.toUpperCase()} ${path}`] = operationObject;
-                }
-            }
-        }
-        return result;
+        return command;
     }
-    static validateSpec(spec, parser, isSwaggerFile, options) {
+    static validateSpec(spec, parser, apiMap, isSwaggerFile, options) {
         const errors = [];
         const warnings = [];
         if (isSwaggerFile) {
@@ -705,7 +483,6 @@ class Utils {
                 content: ConstantString.ConvertSwaggerToOpenAPI,
             });
         }
-        // Server validation
         const serverErrors = Utils.validateServer(spec, options);
         errors.push(...serverErrors);
         // Remote reference not supported
@@ -719,8 +496,8 @@ class Utils {
             });
         }
         // No supported API
-        const apiMap = Utils.listSupportedAPIs(spec, options);
-        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,
@@ -729,8 +506,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);
             }
         }
@@ -786,6 +563,389 @@ class Utils {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+class Validator {
+    validateMethodAndPath(method, path) {
+        const result = { isValid: true, reason: [] };
+        if (this.options.allowMethods && !this.options.allowMethods.includes(method)) {
+            result.isValid = false;
+            result.reason.push(ErrorType.MethodNotAllowed);
+            return result;
+        }
+        const pathObj = this.spec.paths[path];
+        if (!pathObj || !pathObj[method]) {
+            result.isValid = false;
+            result.reason.push(ErrorType.UrlPathNotExist);
+            return result;
+        }
+        return result;
+    }
+    validateResponse(method, path) {
+        const result = { isValid: true, reason: [] };
+        const operationObject = this.spec.paths[path][method];
+        const { json, multipleMediaType } = Utils.getResponseJson(operationObject);
+        // only support response body only contains “application/json” content type
+        if (multipleMediaType) {
+            result.reason.push(ErrorType.ResponseContainMultipleMediaTypes);
+        }
+        else if (Object.keys(json).length === 0) {
+            // response body should not be empty
+            result.reason.push(ErrorType.ResponseJsonIsEmpty);
+        }
+        return result;
+    }
+    validateServer(method, path) {
+        const pathObj = this.spec.paths[path];
+        const result = { isValid: true, reason: [] };
+        const operationObject = pathObj[method];
+        const rootServer = this.spec.servers && this.spec.servers[0];
+        const methodServer = this.spec.paths[path].servers && this.spec.paths[path].servers[0];
+        const operationServer = operationObject.servers && operationObject.servers[0];
+        const serverUrl = operationServer || methodServer || rootServer;
+        if (!serverUrl) {
+            // should contain server URL
+            result.reason.push(ErrorType.NoServerInformation);
+        }
+        else {
+            // server url should be absolute url with https protocol
+            const serverValidateResult = Utils.checkServerUrl([serverUrl]);
+            result.reason.push(...serverValidateResult.map((item) => item.type));
+        }
+        return result;
+    }
+    validateAuth(method, path) {
+        const pathObj = this.spec.paths[path];
+        const operationObject = pathObj[method];
+        const securities = operationObject.security;
+        const authSchemeArray = Utils.getAuthArray(securities, this.spec);
+        if (authSchemeArray.length === 0) {
+            return { isValid: true, reason: [] };
+        }
+        if (this.options.allowAPIKeyAuth ||
+            this.options.allowOauth2 ||
+            this.options.allowBearerTokenAuth) {
+            // Currently we don't support multiple auth in one operation
+            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
+                return {
+                    isValid: false,
+                    reason: [ErrorType.MultipleAuthNotSupported],
+                };
+            }
+            for (const auths of authSchemeArray) {
+                if (auths.length === 1) {
+                    if ((this.options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
+                        (this.options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
+                        (this.options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
+                        return { isValid: true, reason: [] };
+                    }
+                }
+            }
+        }
+        return { isValid: false, reason: [ErrorType.AuthTypeIsNotSupported] };
+    }
+    checkPostBodySchema(schema, isRequired = 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;
+        const isCopilot = this.projectType === ProjectType.Copilot;
+        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+            paramResult.isValid = false;
+            paramResult.reason = [ErrorType.RequestBodyContainsNestedObject];
+            return paramResult;
+        }
+        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 = this.checkPostBodySchema(properties[property], isRequired);
+                paramResult.requiredNum += result.requiredNum;
+                paramResult.optionalNum += result.optionalNum;
+                paramResult.isValid = paramResult.isValid && result.isValid;
+                paramResult.reason.push(...result.reason);
+            }
+        }
+        else {
+            if (isRequiredWithoutDefault && !isCopilot) {
+                paramResult.isValid = false;
+                paramResult.reason.push(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
+            }
+        }
+        return paramResult;
+    }
+    checkParamSchema(paramObject) {
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        if (!paramObject) {
+            return paramResult;
+        }
+        const isCopilot = this.projectType === ProjectType.Copilot;
+        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;
+            }
+            if (schema.type !== "boolean" &&
+                schema.type !== "string" &&
+                schema.type !== "number" &&
+                schema.type !== "integer") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
+                }
+                continue;
+            }
+            if (param.in === "query" || param.in === "path") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.requiredNum = paramResult.requiredNum + 1;
+                }
+                else {
+                    paramResult.optionalNum = paramResult.optionalNum + 1;
+                }
+            }
+        }
+        return paramResult;
+    }
+    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;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class CopilotValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = ProjectType.Copilot;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate auth
+        const authCheckResult = this.validateAuth(method, path);
+        result.reason.push(...authCheckResult.reason);
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        // validate response
+        const validateResponseResult = this.validateResponse(method, path);
+        result.reason.push(...validateResponseResult.reason);
+        // validate requestBody
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        if (requestJsonBody) {
+            const requestBodySchema = requestJsonBody.schema;
+            if (requestBodySchema.type !== "object") {
+                result.reason.push(ErrorType.PostBodySchemaIsNotJson);
+            }
+            const requestBodyParamResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
+            result.reason.push(...requestBodyParamResult.reason);
+        }
+        // validate parameters
+        const paramObject = operationObject.parameters;
+        const paramResult = this.checkParamSchema(paramObject);
+        result.reason.push(...paramResult.reason);
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class SMEValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = ProjectType.SME;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate auth
+        const authCheckResult = this.validateAuth(method, path);
+        result.reason.push(...authCheckResult.reason);
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        // validate response
+        const validateResponseResult = this.validateResponse(method, path);
+        result.reason.push(...validateResponseResult.reason);
+        let postBodyResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        // validate requestBody
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        if (requestJsonBody) {
+            const requestBodySchema = requestJsonBody.schema;
+            postBodyResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
+            result.reason.push(...postBodyResult.reason);
+        }
+        // validate parameters
+        const paramObject = operationObject.parameters;
+        const paramResult = this.checkParamSchema(paramObject);
+        result.reason.push(...paramResult.reason);
+        // validate total parameters count
+        if (paramResult.isValid && postBodyResult.isValid) {
+            const paramCountResult = this.validateParamCount(postBodyResult, paramResult);
+            result.reason.push(...paramCountResult.reason);
+        }
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+    validateParamCount(postBodyResult, paramResult) {
+        const result = { isValid: true, reason: [] };
+        const totalRequiredParams = postBodyResult.requiredNum + paramResult.requiredNum;
+        const totalParams = totalRequiredParams + postBodyResult.optionalNum + paramResult.optionalNum;
+        if (totalRequiredParams > 1) {
+            if (!this.options.allowMultipleParameters ||
+                totalRequiredParams > SMEValidator.SMERequiredParamsMaxNum) {
+                result.reason.push(ErrorType.ExceededRequiredParamsLimit);
+            }
+        }
+        else if (totalParams === 0) {
+            result.reason.push(ErrorType.NoParameter);
+        }
+        return result;
+    }
+}
+SMEValidator.SMERequiredParamsMaxNum = 5;
+
+// Copyright (c) Microsoft Corporation.
+class TeamsAIValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = ProjectType.TeamsAi;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+}
+
+class ValidatorFactory {
+    static create(spec, options) {
+        var _a;
+        const type = (_a = options.projectType) !== null && _a !== void 0 ? _a : ProjectType.SME;
+        switch (type) {
+            case ProjectType.SME:
+                return new SMEValidator(spec, options);
+            case ProjectType.Copilot:
+                return new CopilotValidator(spec, options);
+            case ProjectType.TeamsAi:
+                return new TeamsAIValidator(spec, options);
+            default:
+                throw new Error(`Invalid project type: ${type}`);
+        }
+    }
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * A class that parses an OpenAPI specification file and provides methods to validate, list, and generate artifacts.
@@ -842,7 +1002,8 @@ class SpecParser {
                     ],
                 };
             }
-            return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options);
+            const apiMap = this.getAPIs(this.spec);
+            return Utils.validateSpec(this.spec, this.parser, apiMap, !!this.isSwaggerFile, this.options);
         }
         catch (err) {
             throw new SpecParserError(err.toString(), ErrorType.ValidateFailed);
@@ -851,17 +1012,20 @@ class SpecParser {
     async listSupportedAPIInfo() {
         try {
             await this.loadSpec();
-            const apiMap = this.getAllSupportedAPIs(this.spec);
+            const apiMap = this.getAPIs(this.spec);
             const apiInfos = [];
             for (const key in apiMap) {
-                const pathObjectItem = apiMap[key];
+                const { operation, isValid } = apiMap[key];
+                if (!isValid) {
+                    continue;
+                }
                 const [method, path] = key.split(" ");
-                const operationId = pathObjectItem.operationId;
+                const operationId = operation.operationId;
                 // In Browser environment, this api is by default not support api without operationId
                 if (!operationId) {
                     continue;
                 }
-                const [command, warning] = Utils.parseApiInfo(pathObjectItem, this.options);
+                const command = Utils.parseApiInfo(operation, this.options);
                 const apiInfo = {
                     method: method,
                     path: path,
@@ -870,9 +1034,6 @@ class SpecParser {
                     parameters: command.parameters,
                     description: command.description,
                 };
-                if (warning) {
-                    apiInfo.warning = warning;
-                }
                 apiInfos.push(apiInfo);
             }
             return apiInfos;
@@ -931,21 +1092,42 @@ class SpecParser {
             this.spec = (await this.parser.dereference(clonedUnResolveSpec));
         }
     }
-    getAllSupportedAPIs(spec) {
+    getAPIs(spec) {
         if (this.apiMap !== undefined) {
             return this.apiMap;
         }
-        const result = Utils.listSupportedAPIs(spec, this.options);
+        const result = this.listAPIs(spec);
         this.apiMap = result;
         return result;
     }
+    listAPIs(spec) {
+        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 = this.options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
+                    const validator = ValidatorFactory.create(spec, this.options);
+                    const validateResult = validator.validateAPI(method, path);
+                    result[`${method.toUpperCase()} ${path}`] = {
+                        operation: operationObject,
+                        isValid: validateResult.isValid,
+                        reason: validateResult.reason,
+                    };
+                }
+            }
+        }
+        return result;
+    }
 }
 
 // Copyright (c) Microsoft Corporation.
 class AdaptiveCardGenerator {
     static generateAdaptiveCard(operationItem) {
         try {
-            const json = Utils.getResponseJson(operationItem);
+            const { json } = Utils.getResponseJson(operationItem);
             let cardBody = [];
             let schema = json.schema;
             let jsonPath = "$";