@azure-tools/typespec-go 0.10.7 → 0.11.1

package/dist/typespec-go/src/tcgcadapter/clients.js

@@ -275,7 +275,7 @@ export class ClientAdapter {
                 goClient.instance = constructable;
                 // if no authentication type was specified, or the noAuth scheme was
                 // explicitly specified, then include the WithNoCredential constructor
-                if (authType === AuthTypes.Default || (authType & AuthTypes.NoAuth) === AuthTypes.NoAuth) {
+                if (authType === AuthTypes.Default || (authType & AuthTypes.NoAuth) !== 0) {
                     goClient.instance.constructors.push(new go.Constructor(this.ta.getPkg(), `New${clientName}WithNoCredential`));
                 }
                 // propagate ctor params to all client ctors
@@ -383,7 +383,7 @@ export class ClientAdapter {
     adaptURIParam(sdkParam, forceRequired) {
         let paramType;
         if (sdkParam.isApiVersionParam) {
-            paramType = new go.String();
+            paramType = this.ta.getStringType();
         }
         else {
             paramType = this.ta.getWireType(sdkParam.type, true, false);
@@ -429,7 +429,7 @@ export class ClientAdapter {
             }
         }
         const setLROInfo = function (goMethod, sdkMethod) {
-            const lroOptions = hasDecorator('Azure.Core.@useFinalStateVia', sdkMethod.decorators);
+            const lroOptions = helpers.hasDecorator('@useFinalStateVia', sdkMethod.decorators);
             if (lroOptions) {
                 goMethod.finalStateVia = lroOptions['finalState'];
             }
@@ -442,34 +442,26 @@ export class ClientAdapter {
                     .join('.');
             }
         };
-        const setPageableInfo = function (goMethod, sdkMethod) {
-            if (sdkMethod.pagingMetadata.nextLinkVerb) {
-                switch (sdkMethod.pagingMetadata.nextLinkVerb) {
-                    case 'GET':
-                        // we default to GET in the ctor for PageableMethod
-                        break;
-                    case 'POST':
-                        goMethod.nextLinkVerb = 'post';
-                        break;
-                    default:
-                        sdkMethod.pagingMetadata.nextLinkVerb;
-                }
-            }
-            if (sdkMethod.pagingMetadata.nextLinkSegments) {
-                goMethod.nextLinkName = capitalize(sdkMethod.pagingMetadata.nextLinkSegments
-                    .map((segment) => {
-                    if (segment.kind === 'property') {
-                        return ensureNameCase(segment.name);
-                    }
-                    else {
-                        throw new AdapterError('UnsupportedTsp', `unsupported next link segment kind ${segment.kind}`, sdkMethod.__raw?.node);
+        const setPageableInfo = (goMethod, sdkMethod) => {
+            return (paramsMap, respHeadersMap) => {
+                if (sdkMethod.pagingMetadata.nextLinkVerb) {
+                    switch (sdkMethod.pagingMetadata.nextLinkVerb) {
+                        case 'GET':
+                            // we default to GET in the ctor for PageableMethod
+                            break;
+                        case 'POST':
+                            goMethod.nextLinkVerb = 'post';
+                            break;
+                        default:
+                            sdkMethod.pagingMetadata.nextLinkVerb;
                     }
-                })
-                    .join('.'));
-            }
+                }
+                goMethod.strategy = this.adaptPagingStrategy(sdkMethod, paramsMap, respHeadersMap);
+            };
         };
         const statusCodes = getStatusCodes(sdkMethod.operation);
         let method;
+        let applyPageableInfo;
         switch (sdkMethod.kind) {
             case 'basic':
                 method = new go.SyncMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
@@ -479,7 +471,7 @@ export class ClientAdapter {
                     throw new AdapterError('UnsupportedTsp', `paging with re-injected parameters is not supported`, sdkMethod.__raw?.node);
                 }
                 method = new go.PageableMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
-                setPageableInfo(method, sdkMethod);
+                applyPageableInfo = setPageableInfo(method, sdkMethod);
                 break;
             case 'lro':
                 method = new go.LROMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
@@ -488,7 +480,7 @@ export class ClientAdapter {
             case 'lropaging':
                 method = new go.LROPageableMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
                 setLROInfo(method, sdkMethod);
-                setPageableInfo(method, sdkMethod);
+                applyPageableInfo = setPageableInfo(method, sdkMethod);
                 break;
             default:
                 sdkMethod;
@@ -497,7 +489,79 @@ export class ClientAdapter {
         method.docs.summary = sdkMethod.summary;
         method.docs.description = sdkMethod.doc;
         goClient.methods.push(method);
-        this.populateMethod(sdkMethod, method);
+        const pageableInfo = this.populateMethod(sdkMethod, method);
+        // NOTE: we can't apply pageable info until the method has been populated
+        applyPageableInfo?.(pageableInfo.params, pageableInfo.respHeaders);
+    }
+    /**
+     * creates the pageable strategy based on the method definition.
+     * returns undefined if no strategy is required.
+     *
+     * @param sdkMethod the tcgc pageable method for which to create a strategy
+     * @returns the pageable strategy or undefined
+     */
+    adaptPagingStrategy(sdkMethod, paramsMap, respHeadersMap) {
+        const buildNextLinkPath = (segments) => {
+            // build the field path for the next link segments
+            const nextLinkPath = new Array();
+            for (const segment of segments) {
+                if (segment.kind !== 'property') {
+                    throw new AdapterError('InternalError', `unexpected kind ${segment.kind} for next link segment in operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                }
+                const nextLinkField = this.ta.fieldsMap.get(segment);
+                if (!nextLinkField) {
+                    // the most likely explanation for this is lack of reference equality
+                    throw new AdapterError('InternalError', `missing next link field name ${segment.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                }
+                nextLinkPath.push(nextLinkField);
+            }
+            return nextLinkPath;
+        };
+        if (sdkMethod.pagingMetadata.nextLinkOperation) {
+            throw new AdapterError('UnsupportedTsp', 'next page operation NYI', sdkMethod.__raw?.node);
+        }
+        else if (sdkMethod.pagingMetadata.nextLinkSegments) {
+            return new go.PageableStrategyNextLink(buildNextLinkPath(sdkMethod.pagingMetadata.nextLinkSegments));
+        }
+        else if (sdkMethod.pagingMetadata.continuationTokenParameterSegments && sdkMethod.pagingMetadata.continuationTokenResponseSegments) {
+            const tokenReq = sdkMethod.pagingMetadata.continuationTokenParameterSegments[0];
+            const tokenResp = sdkMethod.pagingMetadata.continuationTokenResponseSegments[0];
+            // find the continuation token parameter
+            let requestToken;
+            switch (tokenReq.kind) {
+                case 'method': {
+                    const tokenParam = paramsMap.get(tokenReq);
+                    if (!tokenParam) {
+                        throw new AdapterError('InternalError', `missing continuation token request parameter name ${tokenReq.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                    }
+                    requestToken = tokenParam;
+                    break;
+                }
+                default:
+                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, tokenReq.__raw?.node);
+            }
+            // find the continuation token response
+            let responseToken;
+            switch (tokenResp.kind) {
+                case 'property': {
+                    responseToken = new go.PageableStrategyNextLink(buildNextLinkPath(sdkMethod.pagingMetadata.continuationTokenResponseSegments));
+                    break;
+                }
+                case 'responseheader': {
+                    const tokenHeader = respHeadersMap.get(tokenResp);
+                    if (!tokenHeader) {
+                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                    }
+                    responseToken = tokenHeader;
+                    break;
+                }
+                default:
+                    throw new AdapterError('InternalError', `missing continuation token`, sdkMethod.__raw?.node);
+            }
+            return new go.PageableStrategyContinuationToken(requestToken, responseToken);
+        }
+        // operation is pageable but doesn't yet support fetching subsequent pages
+        return undefined;
     }
     populateMethod(sdkMethod, method) {
         if (method.kind === 'nextPageMethod') {
@@ -525,25 +589,22 @@ export class ClientAdapter {
         }
         method.optionalParamsGroup = new go.ParameterGroup(this.ta.getPkg(), optsGroupName, optionalParamsGroupName, false, 'method');
         method.optionalParamsGroup.docs.summary = createOptionsTypeDescription(optionalParamsGroupName, this.getMethodNameForDocComment(method));
-        method.returns = this.adaptResponseEnvelope(sdkMethod, method);
-        // find the api version param to use for the doc comment.
-        // we can't use sdkMethod.apiVersions as that includes all
-        // of the api versions supported by the service.
-        for (const opParam of sdkMethod.operation.parameters) {
-            if (opParam.isApiVersionParam && opParam.clientDefaultValue) {
-                method.apiVersions.push(opParam.clientDefaultValue);
-                break;
-            }
-        }
+        const respInfo = this.adaptResponseEnvelope(sdkMethod, method);
+        method.returns = respInfo.respEnv;
         const paramMapping = this.adaptMethodParameters(sdkMethod, method);
         // we must do this after adapting method params as it can add optional params
         this.ta.getPkg().paramGroups.push(this.adaptParameterGroup(method.optionalParamsGroup));
         if (this.ta.codeModel.options.generateExamples) {
-            this.adaptHttpOperationExamples(sdkMethod, method, paramMapping);
+            this.adaptHttpOperationExamples(sdkMethod, method, paramMapping.exampleParams);
         }
+        return {
+            params: paramMapping.paramsMap,
+            respHeaders: respInfo.respHeaders,
+        };
     }
     adaptMethodParameters(sdkMethod, method) {
         const paramMapping = new Map();
+        const pageableParamsMap = new Map();
         let optionalGroup;
         if (method.kind !== 'nextPageMethod') {
             // NextPageMethods don't have optional params
@@ -637,10 +698,11 @@ export class ClientAdapter {
                     }
                     case 'binary':
                         if (opParam.defaultContentType.match(/multipart/i)) {
-                            adaptedParam = new go.MultipartFormBodyParameter(paramName, this.ta.getReadSeekCloser(false), paramStyle, byVal);
+                            adaptedParam = this.adaptMultipartFormParameter(param, paramStyle, byVal);
                         }
                         else {
-                            adaptedParam = new go.BodyParameter(paramName, contentType, `"${opParam.defaultContentType}"`, this.ta.getReadSeekCloser(false), paramStyle, byVal);
+                            const contentTypeLiteral = this.ta.getLiteral(this.ta.getStringType(), opParam.defaultContentType);
+                            adaptedParam = new go.BodyParameter(paramName, contentType, contentTypeLiteral, this.ta.getReadSeekCloser(false), paramStyle, byVal);
                         }
                         break;
                     default:
@@ -667,7 +729,7 @@ export class ClientAdapter {
                 }
                 if (correspondingOpParams.length === 0) {
                     // No properties mapped to HTTP params, treat as regular parameter
-                    adaptedParam = this.adaptMethodParameter(opParam, method.httpMethod);
+                    adaptedParam = this.adaptMethodParameter(method, opParam);
                 }
                 else {
                     // Parameter group handling:
@@ -687,7 +749,7 @@ export class ClientAdapter {
                     for (let i = 0; i < modelProperties.length; i++) {
                         const property = modelProperties[i];
                         const propertyOpParam = correspondingOpParams[i];
-                        const adaptedPropertyParam = this.adaptMethodParameter(propertyOpParam, method.httpMethod);
+                        const adaptedPropertyParam = this.adaptMethodParameter(method, propertyOpParam);
                         adaptedPropertyParam.docs.summary = property.summary;
                         adaptedPropertyParam.docs.description = property.doc;
                         if (adaptedPropertyParam.style === 'required' || adaptedPropertyParam.style === 'literal') {
@@ -730,10 +792,20 @@ export class ClientAdapter {
                 }
             }
             else {
-                adaptedParam = this.adaptMethodParameter(opParam, method.httpMethod);
+                adaptedParam = this.adaptMethodParameter(method, opParam);
+                if (method.kind !== 'nextPageMethod' && go.isPageableMethod(method)) {
+                    switch (adaptedParam.kind) {
+                        case 'headerScalarParam':
+                        case 'queryScalarParam':
+                            pageableParamsMap.set(param, adaptedParam);
+                    }
+                }
             }
             adaptedParam.docs.summary = param.summary;
             adaptedParam.docs.description = param.doc;
+            if (go.isClientSideDefault(adaptedParam.style) && !adaptedParam.docs.summary && !adaptedParam.docs.description) {
+                adaptedParam.docs.summary = helpers.getClientDefaultValueDoc(adaptedParam.style.defaultValue);
+            }
             addParameterToMethod(adaptedParam, opParam);
             if (adaptedParam.style !== 'required' && adaptedParam.style !== 'literal') {
                 // add optional method param to the options param group
@@ -748,7 +820,7 @@ export class ClientAdapter {
         // look for them in the operation parameters.
         for (const opParam of allOpParams) {
             if (opParam.onClient) {
-                const adaptedParam = this.adaptMethodParameter(opParam, method.httpMethod);
+                const adaptedParam = this.adaptMethodParameter(method, opParam);
                 adaptedParam.docs.summary = opParam.summary;
                 adaptedParam.docs.description = opParam.doc;
                 method.parameters.unshift(adaptedParam);
@@ -783,7 +855,10 @@ export class ClientAdapter {
                 }
             }
         }
-        return paramMapping;
+        return {
+            exampleParams: paramMapping,
+            paramsMap: pageableParamsMap,
+        };
     }
     adaptContentType(contentTypeStr) {
         // we only recognize/support JSON, text, and XML content types, so assume anything else is binary
@@ -803,16 +878,30 @@ export class ClientAdapter {
     /**
      * adapts the provided operation parameter to a Go method parameter
      *
+     * @param method the method to which the parameter belongs
      * @param opParam the operation parameter to adapt
-     * @param verb the HTTP verb used for the operation to which the parameter belongs
      * @returns the adapted Go method parameter
      */
-    adaptMethodParameter(opParam, verb) {
+    adaptMethodParameter(method, opParam) {
         if (opParam.isApiVersionParam) {
             // we emit the api version param inline as a literal, never as a param.
             // the ClientOptions.APIVersion setting is used to change the version.
-            const paramType = opParam.clientDefaultValue ? new go.Literal(new go.String(), opParam.clientDefaultValue) : new go.String();
-            const paramStyle = opParam.clientDefaultValue ? 'literal' : opParam.optional ? 'optional' : 'required';
+            let paramType;
+            let paramStyle;
+            if (opParam.clientDefaultValue) {
+                const client = method.receiver.type;
+                if (!client.apiVersion) {
+                    // first method for this client, so apiVersion hasn't been set yet
+                    const literalValue = new go.Literal(this.ta.getStringType(), opParam.clientDefaultValue);
+                    client.apiVersion = new go.ConstantDef(`default${client.name}Version`, literalValue);
+                }
+                paramType = new go.Literal(client.apiVersion, client.apiVersion.name);
+                paramStyle = 'literal';
+            }
+            else {
+                paramType = this.ta.getStringType();
+                paramStyle = opParam.optional ? 'optional' : 'required';
+            }
             const paramLoc = opParam.onClient ? 'client' : 'method';
             let apiVersionParam;
             switch (opParam.kind) {
@@ -862,7 +951,7 @@ export class ClientAdapter {
         if (opParam.kind === 'body') {
             const contentType = this.adaptContentType(opParam.defaultContentType);
             // only force modeled body params to be required (binary payloads can be optional)
-            if (contentType !== 'binary' && (verb === 'patch' || verb === 'put')) {
+            if (contentType !== 'binary' && (method.httpMethod === 'patch' || method.httpMethod === 'put')) {
                 paramStyle = 'required';
             }
         }
@@ -873,7 +962,7 @@ export class ClientAdapter {
             case 'body':
                 // TODO: form data? (non-multipart)
                 if (opParam.defaultContentType.match(/multipart/i)) {
-                    adaptedParam = new go.MultipartFormBodyParameter(paramName, this.ta.getWireType(methodParam.type, false, true), paramStyle, byVal);
+                    adaptedParam = this.adaptMultipartFormParameter(methodParam, paramStyle, byVal);
                 }
                 else {
                     const contentType = this.adaptContentType(opParam.defaultContentType);
@@ -882,7 +971,8 @@ export class ClientAdapter {
                         // tcgc models binary params as 'bytes' but we want an io.ReadSeekCloser
                         bodyType = this.ta.getReadSeekCloser(methodParam.type.kind === 'array');
                     }
-                    adaptedParam = new go.BodyParameter(paramName, contentType, `"${opParam.defaultContentType}"`, bodyType, paramStyle, byVal);
+                    const contentTypeLiteral = this.ta.getLiteral(this.ta.getStringType(), opParam.defaultContentType);
+                    adaptedParam = new go.BodyParameter(paramName, contentType, contentTypeLiteral, bodyType, paramStyle, byVal);
                     if (contentType === 'XML' && methodParam.type.kind === 'array') {
                         // this is for compat with autorest.go
                         adaptedParam.xml = new go.XMLInfo();
@@ -940,6 +1030,46 @@ export class ClientAdapter {
         }
         return adaptedParam;
     }
+    /**
+     * adapts a multipart form body parameter from its tcgc representation.
+     * for generated wrapper types (isGeneratedName), unwraps to the inner property.
+     * for file parts with a fixed content type (e.g. HttpPart<File<"image/png">>),
+     * uses a MultipartContent type with the content type baked in.
+     */
+    adaptMultipartFormParameter(param, paramStyle, byVal) {
+        let paramName = param.name;
+        if (param.type.kind !== 'model') {
+            throw new AdapterError('InternalError', `unexpected kind ${param.type.kind}`, param.__raw?.node);
+        }
+        let paramType = param.type;
+        let multipartOptions;
+        if (paramType.isGeneratedName) {
+            // tcgc wraps inline multipart params in a generated model with a single property.
+            // unwrap to the inner property to get the actual param name and type.
+            if (paramType.properties.length !== 1) {
+                throw new AdapterError('InternalError', `unexpected number of properties: ${paramType.properties.length}`, paramType.__raw?.node);
+            }
+            const prop = paramType.properties[0];
+            paramName = prop.name;
+            multipartOptions = prop.serializationOptions.multipart;
+            paramType = prop.type;
+        }
+        let type;
+        // only use MultipartContent for file parts with a fixed content type.
+        // non-file parts (e.g. HttpPart<{ @body body: float64; @header contentType: "text/plain" }>)
+        // should retain their underlying type (e.g. float64).
+        if (multipartOptions?.isFilePart && multipartOptions.contentType?.type.kind === 'constant' && multipartOptions.defaultContentTypes.length === 1) {
+            type = this.ta.getMultipartContent(paramType.kind === 'array', multipartOptions.defaultContentTypes[0]);
+        }
+        else if (paramType.kind === 'bytes' && paramType.encode === 'bytes') {
+            type = this.ta.getReadSeekCloser(false);
+        }
+        else {
+            type = this.ta.getWireType(paramType, true, true);
+        }
+        paramName = getEscapedReservedName(ensureNameCase(paramName, paramStyle === 'required'), 'Param');
+        return new go.MultipartFormBodyParameter(paramName, type, paramStyle, byVal);
+    }
     getMethodNameForDocComment(method) {
         let methodName;
         switch (method.kind) {
@@ -972,6 +1102,7 @@ export class ClientAdapter {
         }
         const respEnv = new go.ResponseEnvelope(respEnvName, { summary: createResponseEnvelopeDescription(respEnvName, this.getMethodNameForDocComment(method)) }, method);
         this.ta.getPkg().responseEnvelopes.push(respEnv);
+        const pageableRespHeadersMap = new Map();
         // add any headers
         const addedHeaders = new Set();
         if (!go.isLROMethod(method)) {
@@ -990,6 +1121,9 @@ export class ClientAdapter {
                     }
                     else {
                         headerResp = new go.HeaderScalarResponse(ensureNameCase(httpHeader.name), this.adaptHeaderScalarType(httpHeader.type, false), httpHeader.serializedName, helpers.isTypePassedByValue(httpHeader.type));
+                        if (go.isPageableMethod(method)) {
+                            pageableRespHeadersMap.set(httpHeader, headerResp);
+                        }
                     }
                     headerResp.docs.summary = httpHeader.summary;
                     headerResp.docs.description = httpHeader.doc;
@@ -1006,7 +1140,10 @@ export class ClientAdapter {
         }
         if (!sdkResponseType) {
             // method doesn't return a type, so we're done
-            return respEnv;
+            return {
+                respEnv: respEnv,
+                respHeaders: pageableRespHeadersMap,
+            };
         }
         if (sdkResponseType.kind === 'nullable') {
             // unwrap the nullable type, this will only happen for operations with two responses and one of them does not have a body
@@ -1057,7 +1194,10 @@ export class ClientAdapter {
         if (contentType === 'binary') {
             respEnv.result = new go.BinaryResult('Body');
             respEnv.result.docs.summary = 'Body contains the streaming response.';
-            return respEnv;
+            return {
+                respEnv: respEnv,
+                respHeaders: pageableRespHeadersMap,
+            };
         }
         else if (sdkResponseType.kind === 'model') {
             let modelType;
@@ -1141,7 +1281,10 @@ export class ClientAdapter {
                 throw new AdapterError('InternalError', `invalid monomorphic result type ${resultType.kind}`, sdkResponseType.__raw?.node);
             }
         }
-        return respEnv;
+        return {
+            respEnv: respEnv,
+            respHeaders: pageableRespHeadersMap,
+        };
     }
     /**
      * creates the monomorphic response field name based on its type.
@@ -1263,7 +1406,7 @@ export class ClientAdapter {
             if (param.isApiVersionParam) {
                 // we force the API version param type to a string
                 // so it matches the ClientOptions.APIVersion type
-                adaptedType = new go.String();
+                adaptedType = this.ta.getStringType();
             }
             else {
                 const adaptedWireType = this.ta.getWireType(param.type, false, false);
@@ -1272,17 +1415,7 @@ export class ClientAdapter {
                 }
                 adaptedType = adaptedWireType;
             }
-            if (adaptedType.kind === 'constant') {
-                // find the matching constant for the clientDefaultValue
-                for (const constValue of adaptedType.values) {
-                    if (constValue.value === param.clientDefaultValue) {
-                        return new go.ClientSideDefault(new go.Literal(adaptedType, constValue));
-                    }
-                }
-                throw new AdapterError('InternalError', `didn't find clientDefaultValue constant with value ${param.clientDefaultValue} for parameter`, param.__raw?.node);
-            }
-            // non-constant clientDefaultValue
-            return new go.ClientSideDefault(new go.Literal(adaptedType, param.clientDefaultValue));
+            return new go.ClientSideDefault(this.ta.getLiteral(adaptedType, param.clientDefaultValue, helpers.isExtensibleEnum(param.type)));
         }
         else if (param.optional) {
             return 'optional';
@@ -1447,9 +1580,8 @@ export class ClientAdapter {
                 if (goType.kind === 'interface' || goType.kind === 'model' || goType.kind === 'polymorphicModel') {
                     let concreteType;
                     if (goType.kind === 'interface') {
-                        concreteType = goType.possibleTypes.find(
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                        (t) => t.discriminatorValue?.literal === exampleType.type.discriminatorValue || t.discriminatorValue?.literal.value === exampleType.type.discriminatorValue);
+                        concreteType = goType.possibleTypes.find((t) => t.discriminatorValue?.literal === exampleType.type.discriminatorValue ||
+                            (t.discriminatorValue?.literal).value === exampleType.type.discriminatorValue);
                         if (concreteType === undefined) {
                             // can't find the sub type of a discriminated type, fallback to the base type
                             concreteType = goType.rootType;
@@ -1491,22 +1623,6 @@ export class ClientAdapter {
         throw new AdapterError('InternalError', `can not map go type into example type ${exampleType.kind}`);
     }
 }
-/**
- * returns the record for the specified decorator's arguments if it exists
- *
- * @param name the name of the decorator to find
- * @param decorators the array of decorators to search
- * @returns the decorator's record of arguments or undefined
- */
-/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-function hasDecorator(name, decorators) {
-    for (const decorator of decorators) {
-        if (decorator.name === name) {
-            return decorator.arguments;
-        }
-    }
-    return undefined;
-}
 function isHttpStatusCodeRange(statusCode) {
     return statusCode.start !== undefined;
 }