@azure-tools/typespec-rust 0.20.0 → 0.22.0

package/dist/src/tcgcadapter/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/tcgcadapter/adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/tcgcadapter/adapter.ts"],"names":[],"mappings":"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"}

package/dist/src/tcgcadapter/adapter.js

@@ -2,7 +2,7 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-// cspell: ignore responseheader subclients lropaging
+// cspell: ignore addl responseheader subclients lropaging
 import * as codegen from '@azure-tools/codegen';
 import { values } from '@azure-tools/linq';
 import { NoTarget } from '@typespec/compiler';
@@ -23,6 +23,12 @@ export class AdapterError extends Error {
         this.target = target !== null && target !== void 0 ? target : NoTarget;
     }
 }
+/**
+ * ExternalError is thrown when an external component reports a
+ * diagnostic error that would prevent the emitter from proceeding.
+ */
+export class ExternalError extends Error {
+}
 /** Adapter converts the tcgc code model to a Rust Crate */
 export class Adapter {
     /**
@@ -40,6 +46,15 @@ export class Adapter {
             disableUsageAccessPropagationToBase: true,
         });
         context.program.reportDiagnostics(ctx.diagnostics);
+        for (const diag of ctx.diagnostics) {
+            if (diag.severity === 'error') {
+                // there's no point in continuing if tcgc
+                // has reported diagnostic errors, so exit.
+                // this prevents spurious crashes in the
+                // emitter as our input state is invalid.
+                throw new ExternalError();
+            }
+        }
         return new Adapter(ctx, context.options);
     }
     constructor(ctx, options) {
@@ -173,7 +188,7 @@ export class Adapter {
      * @returns a Rust model
      */
     getModel(model, stack) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (model.name.length === 0) {
             throw new AdapterError('InternalError', 'unnamed model', (_a = model.__raw) === null || _a === void 0 ? void 0 : _a.node); // TODO: this might no longer be an issue
         }
@@ -204,6 +219,7 @@ export class Adapter {
         for (const prop of model.properties) {
             allProps.push(prop);
         }
+        let addlProps = model.additionalProperties;
         let parent = model.baseModel;
         while (parent) {
             for (const parentProp of parent.properties) {
@@ -215,7 +231,14 @@ export class Adapter {
                 }
                 allProps.push(parentProp);
             }
-            // TODO: propagate additional properties https://github.com/Azure/typespec-rust/issues/4
+            // propagate parent's additional properties if we don't yet have any.
+            // if we do, ensure that their kinds match.
+            if (!addlProps) {
+                addlProps = parent.additionalProperties;
+            }
+            else if (parent.additionalProperties && addlProps.kind !== parent.additionalProperties.kind) {
+                throw new AdapterError('UnsupportedTsp', `model ${model.name} has additional properties kind ${addlProps.kind} which conflicts with parent model ${parent.name} additional properties kind ${parent.additionalProperties.kind}`, (_b = model.__raw) === null || _b === void 0 ? void 0 : _b.node);
+            }
             parent = parent.baseModel;
         }
         for (const property of allProps) {
@@ -231,15 +254,25 @@ export class Adapter {
                     // we just adapt it here as a regular model field.
                 }
                 else {
-                    throw new AdapterError('UnsupportedTsp', `model property kind ${property.kind} NYI`, (_b = property.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                    throw new AdapterError('UnsupportedTsp', `model property kind ${(_c = property.__raw) === null || _c === void 0 ? void 0 : _c.kind} NYI`, (_d = property.__raw) === null || _d === void 0 ? void 0 : _d.node);
                 }
             }
             const structField = this.getModelField(property, rustModel.visibility, stack);
             rustModel.fields.push(structField);
         }
+        if (addlProps) {
+            const addlPropsType = this.getHashMap(this.typeToWireType(this.getType(addlProps)));
+            const addlPropsField = new rust.ModelAdditionalProperties('additional_properties', 'pub', this.getOptionType(addlPropsType));
+            addlPropsField.docs.summary = 'contains unnamed additional properties';
+            rustModel.fields.push(addlPropsField);
+        }
         stack.pop();
         return rustModel;
     }
+    getSerializedPropertyName(property) {
+        var _a, _b, _c, _d, _e;
+        return property.kind === 'property' ? (_d = (_b = (_a = property.serializationOptions.json) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = property.serializationOptions.xml) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : (_e = property.serializationOptions.multipart) === null || _e === void 0 ? void 0 : _e.name : undefined;
+    }
     /**
      * converts a tcgc model property to a model field
      *
@@ -249,17 +282,19 @@ export class Adapter {
      * @returns a Rust model field
      */
     getModelField(property, modelVisibility, stack) {
+        var _a;
         let fieldType = this.getType(property.type, stack);
         // if the field's type is a model and it's in the type stack then
         // box it. this is to avoid infinitely recursive type definitions.
         if (fieldType.kind === 'model' && stack.includes(fieldType.name)) {
-            fieldType = new rust.Box(fieldType);
+            fieldType = this.getBoxType(fieldType);
         }
         // for public models each field is always an Option<T>.
         if (modelVisibility === 'pub' || property.optional) {
-            fieldType = new rust.Option(fieldType.kind === 'box' ? fieldType : this.typeToWireType(fieldType));
+            fieldType = this.getOptionType(fieldType.kind === 'box' ? fieldType : this.typeToWireType(fieldType));
         }
-        const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), property.serializedName, modelVisibility, fieldType, property.optional);
+        const serializedName = (_a = this.getSerializedPropertyName(property)) !== null && _a !== void 0 ? _a : property.name;
+        const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), serializedName, modelVisibility, fieldType, property.optional);
         modelField.docs = this.adaptDocs(property.summary, property.doc);
         // if this is a literal, add a doc comment explaining its behavior
         const unwrappedType = shared.unwrapOption(fieldType);
@@ -423,6 +458,16 @@ export class Adapter {
                 throw new AdapterError('UnsupportedTsp', `unhandled tcgc type ${type.kind}`, (_b = type.__raw) === null || _b === void 0 ? void 0 : _b.node);
         }
     }
+    /** returns a Box type */
+    getBoxType(type) {
+        const typeKey = recursiveKeyName('box', type);
+        let boxType = this.types.get(typeKey);
+        if (!boxType) {
+            boxType = new rust.Box(type);
+            this.types.set(typeKey, boxType);
+        }
+        return boxType;
+    }
     /** returns an EncodedBytes type with the specified encoding */
     getEncodedBytes(encoding, asSlice) {
         const keyName = `encodedBytes-${encoding}${asSlice ? '-slice' : ''}`;
@@ -445,6 +490,16 @@ export class Adapter {
         this.types.set(keyName, hashmapType);
         return hashmapType;
     }
+    /** returns an Option<T> where T is specified in type */
+    getOptionType(type) {
+        const typeKey = recursiveKeyName('option', type);
+        let optionType = this.types.get(typeKey);
+        if (!optionType) {
+            optionType = new rust.Option(type);
+            this.types.set(typeKey, optionType);
+        }
+        return optionType;
+    }
     /** returns the specified type wrapped in a Ref */
     getRefType(type) {
         const typeKey = recursiveKeyName('ref', type);
@@ -633,7 +688,7 @@ export class Adapter {
         var _a, _b, _c, _d, _e;
         let clientName = client.name;
         // NOTE: if the client has the @clientName decorator applied then use that verbatim
-        if (parent && !client.decorators.find((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@clientName')) {
+        if (parent && !hasClientNameDecorator(client.decorators)) {
             // for hierarchical clients, the child client names are built
             // from the parent client name. this is because tsp allows subclients
             // with the same name. consider the following example.
@@ -747,12 +802,13 @@ export class Adapter {
                             if (i === 0) {
                                 // the first template arg is always the endpoint parameter.
                                 // note that the types of the param and the field are different.
-                                // NOTE: we use param.name here instead of templateArg.name as
-                                // the former has the fixed name "endpoint" which is what we want.
-                                const adaptedParam = new rust.ClientMethodParameter(param.name, this.getRefType(this.getStringSlice()), false);
+                                // we default to "endpoint" and will use the defined name IFF
+                                // it has the @clientName decorator applied
+                                const endpointName = hasClientNameDecorator(templateArg.decorators) ? snakeCaseName(templateArg.name) : 'endpoint';
+                                const adaptedParam = new rust.ClientEndpointParameter(endpointName);
                                 adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
                                 ctorParams.push(adaptedParam);
-                                rustClient.fields.push(new rust.StructField(param.name, 'pubCrate', new rust.Url(this.crate)));
+                                rustClient.fields.push(new rust.StructField(endpointName, 'pubCrate', new rust.Url(this.crate)));
                                 // if the server's URL is *only* the endpoint parameter then we're done.
                                 // this is the param.type.kind === 'endpoint' case.
                                 if (endpointType.serverUrl === `{${templateArg.serializedName}}`) {
@@ -777,7 +833,7 @@ export class Adapter {
                                 continue;
                             }
                             const clientParam = this.adaptClientParameter(templateArg, rustClient.constructable);
-                            if (clientParam.kind !== 'clientEndpoint') {
+                            if (clientParam.kind !== 'clientSupplementalEndpoint') {
                                 throw new AdapterError('InternalError', `unexpected client parameter kind ${clientParam.kind}`, (_b = templateArg.__raw) === null || _b === void 0 ? void 0 : _b.node);
                             }
                             (_c = rustClient.constructable.endpoint) === null || _c === void 0 ? void 0 : _c.parameters.push(clientParam);
@@ -833,19 +889,21 @@ export class Adapter {
             this.adaptClientAccessor(client, child, rustClient, subClient);
         }
         for (const method of client.methods) {
-            if (method.kind === 'lro' || method.kind === 'lropaging') {
-                // skip LROs for now so that codegen is unblocked
+            if (method.kind === 'lropaging') {
+                // skip Paging LROs for now so that codegen is unblocked
                 // TODO: https://github.com/Azure/typespec-rust/issues/188
                 this.ctx.program.reportDiagnostic({
-                    code: 'LroNotSupported',
+                    code: 'LroPagingNotSupported',
                     severity: 'warning',
-                    message: `skip emitting LRO ${method.name}`,
+                    message: `skip emitting Paging LRO ${method.name}`,
                     target: (_e = (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node) !== null && _e !== void 0 ? _e : NoTarget,
                 });
                 continue;
             }
             this.adaptMethod(method, rustClient);
         }
+        // Set the tracing namespace for tracing based on the client's namespace
+        rustClient.languageIndependentName = client.crossLanguageDefinitionId;
         this.crate.clients.push(rustClient);
         return rustClient;
     }
@@ -868,7 +926,7 @@ export class Adapter {
             throw new AdapterError('InternalError', 'scopes must contain at least one entry', cred.model);
         }
         const ctorTokenCredential = new rust.Constructor('new');
-        const tokenCredParam = new rust.ClientMethodParameter('credential', new rust.Arc(new rust.TokenCredential(this.crate, scopes)), false);
+        const tokenCredParam = new rust.ClientCredentialParameter('credential', new rust.Arc(new rust.TokenCredential(this.crate, scopes)));
         tokenCredParam.docs.summary = `An implementation of [\`TokenCredential\`](azure_core::credentials::TokenCredential) that can provide an Entra ID token to use when authenticating.`;
         ctorTokenCredential.params.push(tokenCredParam);
         ctorTokenCredential.docs.summary = `Creates a new ${rustClient.name}, using Entra ID authentication.`;
@@ -915,7 +973,7 @@ export class Adapter {
                 adaptedParam = new rust.ClientMethodParameter(paramName, paramType, optional);
                 break;
             case 'path':
-                adaptedParam = new rust.ClientEndpointParameter(paramName, paramType, optional, param.serializedName);
+                adaptedParam = new rust.ClientSupplementalEndpointParameter(paramName, paramType, optional, param.serializedName);
                 break;
         }
         adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
@@ -959,7 +1017,7 @@ export class Adapter {
      * @param rustClient the client to which the method belongs
      */
     adaptMethod(method, rustClient) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = codegen.deconstruct(srcMethodName);
@@ -987,6 +1045,12 @@ export class Adapter {
         const methodOptionsField = new rust.StructField('method_options', 'pub', clientMethodOptions);
         methodOptionsField.docs.summary = 'Allows customization of the method call.';
         methodOptionsStruct.fields.push(methodOptionsField);
+        if (method.kind === 'lro') {
+            const pollerOptions = new rust.ExternalType(this.crate, 'PollerOptions', 'azure_core::http::poller');
+            const pollerOptionsField = new rust.StructField('poller_options', 'pub', pollerOptions);
+            pollerOptionsField.docs.summary = 'Allows customization of the [`Poller`](azure_core::http::poller::Poller).';
+            methodOptionsStruct.fields.push(pollerOptionsField);
+        }
         const pub = method.access === 'public' ? 'pub' : 'pubCrate';
         const methodOptions = new rust.MethodOptions(methodOptionsStruct);
         const httpMethod = method.operation.verb;
@@ -1009,6 +1073,9 @@ export class Adapter {
             case 'paging':
                 rustMethod = new rust.PageableMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
                 break;
+            case 'lro':
+                rustMethod = new rust.LroMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
+                break;
             default:
                 throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
         }
@@ -1047,8 +1114,11 @@ export class Adapter {
             else {
                 adaptedParam = this.adaptMethodParameter(opParam);
             }
-            if (adaptedParam.kind === 'headerScalar' || adaptedParam.kind === 'queryScalar') {
-                paramsMap.set(param, adaptedParam);
+            switch (adaptedParam.kind) {
+                case 'headerScalar':
+                case 'queryScalar':
+                    paramsMap.set(param, adaptedParam);
+                    break;
             }
             adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
             rustMethod.params.push(adaptedParam);
@@ -1069,7 +1139,7 @@ export class Adapter {
                     fieldType = field.type;
                 }
                 else {
-                    fieldType = new rust.Option(adaptedParam.type);
+                    fieldType = this.getOptionType(adaptedParam.type);
                 }
                 const optionsField = new rust.StructField(adaptedParam.name, 'pub', fieldType);
                 optionsField.docs = adaptedParam.docs;
@@ -1166,13 +1236,13 @@ export class Adapter {
                 let serde;
                 switch (responseFormat) {
                     case 'JsonFormat':
-                        if (!segment.serializationOptions.json) {
+                        if (segment.kind !== 'property' || !segment.serializationOptions.json) {
                             throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
                         }
                         serde = segment.serializationOptions.json.name;
                         break;
                     case 'XmlFormat':
-                        if (!segment.serializationOptions.xml) {
+                        if (segment.kind !== 'property' || !segment.serializationOptions.xml) {
                             throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
                         }
                         serde = segment.serializationOptions.xml.name;
@@ -1180,11 +1250,14 @@ export class Adapter {
                 }
                 for (let i = 0; i < typeToUnwrap.fields.length; ++i) {
                     const field = typeToUnwrap.fields[i];
+                    if (field.kind === 'additionalProperties') {
+                        continue;
+                    }
                     if (field.serde === serde) {
                         // check if this has already been unwrapped (e.g. type is shared across operations)
                         if (field.type.kind === 'option') {
-                            typeToUnwrap.fields[i].type = typeToUnwrap.fields[i].type.type;
-                            typeToUnwrap.fields[i].flags |= rust.ModelFieldFlags.PageItems;
+                            field.type = (field.type).type;
+                            field.flags |= rust.ModelFieldFlags.PageItems;
                         }
                         // move to the next segment
                         if (field.type.kind === 'model') {
@@ -1206,6 +1279,29 @@ export class Adapter {
                 rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
             }
         }
+        else if (method.kind === 'lro') {
+            const format = responseFormat === 'NoFormat' ? 'JsonFormat' : responseFormat;
+            const responseType = this.typeToWireType(this.getModel(method.lroMetadata.logicalResult));
+            if (responseType.kind !== 'model') {
+                throw new AdapterError('InternalError', `envelope result for ${method.name} is not a model`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
+            }
+            const pushModels = (model, crate) => {
+                if (crate.models.some(m => m === model)) {
+                    return;
+                }
+                crate.models.push(model);
+                for (const field of model.fields) {
+                    let fieldType = field.type;
+                    fieldType = fieldType.kind === 'option' ? fieldType.type : fieldType;
+                    fieldType = fieldType.kind === 'Vec' ? fieldType.type : fieldType;
+                    if (fieldType.kind === 'model') {
+                        pushModels(fieldType, crate);
+                    }
+                }
+            };
+            pushModels(responseType, this.crate);
+            rustMethod.returns = new rust.Result(this.crate, new rust.Poller(this.crate, new rust.Response(this.crate, responseType, format)));
+        }
         else if (method.response.type && !(method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes')) {
             const response = new rust.Response(this.crate, this.typeToWireType(this.getType(method.response.type)), responseFormat);
             rustMethod.returns = new rust.Result(this.crate, response);
@@ -1220,7 +1316,7 @@ export class Adapter {
         }
         else if (method.response.type && method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes') {
             // bytes encoding indicates a streaming binary response
-            rustMethod.returns = new rust.Result(this.crate, new rust.RawResponse(this.crate));
+            rustMethod.returns = new rust.Result(this.crate, new rust.BufResponse(this.crate));
         }
         else {
             rustMethod.returns = new rust.Result(this.crate, new rust.Response(this.crate, this.getUnitType(), responseFormat));
@@ -1304,6 +1400,7 @@ export class Adapter {
         switch (method.returns.type.kind) {
             case 'pageIterator':
             case 'pager':
+            case 'poller':
                 implFor = method.returns.type.type;
                 break;
             case 'response':
@@ -1316,7 +1413,7 @@ export class Adapter {
                 implFor = method.returns.type;
                 break;
             default:
-                // this is RawResponse which should have been previously skipped
+                // this is BufResponse which should have been previously skipped
                 throw new AdapterError('InternalError', `unexpected method return kind ${method.returns.type.kind}`);
         }
         const traitName = `${recursiveTypeName(implFor.content)}Headers`;
@@ -1335,7 +1432,7 @@ export class Adapter {
      * @returns the pageable strategy
      */
     adaptPageableMethodStrategy(method, paramsMap, respHeadersMap) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         if (method.pagingMetadata.nextLinkOperation) {
             // TODO: https://github.com/Azure/autorest.rust/issues/103
             throw new AdapterError('UnsupportedTsp', 'next page operation NYI', (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
@@ -1403,12 +1500,12 @@ export class Adapter {
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `unhandled continuationTokenResponseSegment kind ${tokenResp.kind}`);
+                    throw new AdapterError('InternalError', `missing continuation token`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
             }
             return new rust.PageableStrategyContinuationToken(requestToken, responseToken);
         }
         else {
-            throw new AdapterError('InternalError', `unknown paging strategy for operation ${method.name}`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
+            throw new AdapterError('InternalError', `unknown paging strategy for operation ${method.name}`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
         }
     }
     /**
@@ -1520,14 +1617,12 @@ export class Adapter {
                 {
                     paramType = this.typeToWireType(paramType);
                     let style = 'simple';
-                    {
-                        const tspStyleString = param.style;
-                        if (!['simple', 'path', 'label', 'matrix'].includes(tspStyleString)) {
-                            throw new AdapterError('InternalError', `unsupported style ${tspStyleString} for parameter ${param.serializedName}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
-                        }
-                        else {
-                            style = tspStyleString;
-                        }
+                    const tspStyleString = param.style;
+                    if (!['simple', 'path', 'label', 'matrix'].includes(tspStyleString)) {
+                        throw new AdapterError('InternalError', `unsupported style ${tspStyleString} for parameter ${param.serializedName}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                    }
+                    else {
+                        style = tspStyleString;
                     }
                     if (isRefSlice(paramType)) {
                         adaptedParam = new rust.PathCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
@@ -1679,8 +1774,8 @@ export class Adapter {
         // find the corresponding field within the model so we can get its index
         let serializedName;
         for (const property of opParamType.properties) {
-            if (property.name === param.name) {
-                serializedName = property.serializedName;
+            if (property.kind === 'property' && property.name === param.name) {
+                serializedName = this.getSerializedPropertyName(property);
                 break;
             }
         }
@@ -1783,17 +1878,18 @@ function snakeCaseName(name) {
  * this is idempotent so providing the same type will create
  * the same key.
  *
- * obj is recursively unwrapped, and each layer is used to construct
+ * type is recursively unwrapped, and each layer is used to construct
  * the key. e.g. if obj is a HashMap<String, Vec<i32>> this would
  * unwrap to hashmap-Vec-i32.
  *
  * @param root the starting value for the key
- * @param obj the type for which to create the key
+ * @param type the type for which to create the key
  * @returns a string containing the complete map key
  */
 function recursiveKeyName(root, type) {
     switch (type.kind) {
         case 'Vec':
+        case 'box':
             return recursiveKeyName(`${root}-${type.kind}`, type.type);
         case 'encodedBytes':
             return `${root}-${type.kind}-${type.encoding}${type.slice ? '-slice' : ''}`;
@@ -1806,9 +1902,16 @@ function recursiveKeyName(root, type) {
         case 'offsetDateTime':
             return `${root}-${type.kind}-${type.encoding}${type.utc ? '-utc' : ''}`;
         case 'model':
+        case 'struct':
             return `${root}-${type.kind}-${type.name}`;
+        case 'literal':
+            return `${recursiveKeyName(`${root}-${type.kind}`, type.valueKind)}-${type.value}`;
+        case 'payload':
+            return recursiveKeyName(`${root}-${type.kind}-${type.format}`, type.type);
         case 'ref':
             return recursiveKeyName(`${root}-${type.kind}`, type.type);
+        case 'requestContent':
+            return recursiveKeyName(`${root}-${type.kind}`, type.content);
         case 'safeint':
         case 'decimal':
             return `${root}-${type.kind}${type.stringEncoding ? '-string' : ''}`;
@@ -1872,4 +1975,13 @@ function getXMLKind(decorators, field) {
     }
     return undefined;
 }
+/**
+ * returns true if decorators contains `@clientName`
+ *
+ * @param decorators the array of decorators to inspect
+ * @returns true if `@clientName` is found in decorators
+ */
+function hasClientNameDecorator(decorators) {
+    return decorators.find((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@clientName') !== undefined;
+}
 //# sourceMappingURL=adapter.js.map