@azure-tools/typespec-rust 0.13.2 → 0.14.0

package/dist/src/tcgcadapter/adapter.js

@@ -9,6 +9,18 @@ import * as helpers from './helpers.js';
 import * as naming from './naming.js';
 import * as tcgc from '@azure-tools/typespec-client-generator-core';
 import * as rust from '../codemodel/index.js';
+/**
+ * AdapterError is thrown when the emitter fails to convert part of the tcgc code
+ * model to the emitter code model. this could be due to the emitter not supporting
+ * some tsp construct.
+ */
+export class AdapterError extends Error {
+    constructor(code, message, target) {
+        super(message);
+        this.code = code;
+        this.target = target !== null && target !== void 0 ? target : NoTarget;
+    }
+}
 /** Adapter converts the tcgc code model to a Rust Crate */
 export class Adapter {
     /**
@@ -135,6 +147,7 @@ export class Adapter {
      * @returns a Rust enum value
      */
     getEnumValue(sdkEnumValue) {
+        var _a;
         const enumType = this.getEnum(sdkEnumValue.enumType);
         // find the specified enum value
         for (const value of enumType.values) {
@@ -142,23 +155,31 @@ export class Adapter {
                 return value;
             }
         }
-        throw new Error(`didn't find enum value for name ${sdkEnumValue.name} in enum ${enumType.name}`);
+        throw new AdapterError('InternalError', `didn't find enum value for name ${sdkEnumValue.name} in enum ${enumType.name}`, (_a = sdkEnumValue.__raw) === null || _a === void 0 ? void 0 : _a.node);
     }
     /**
      * converts a tcgc model to a Rust model
      *
      * @param model the tcgc model to convert
+     * @param stack is a stack of model type names used to detect recursive type definitions
      * @returns a Rust model
      */
-    getModel(model) {
+    getModel(model, stack) {
+        var _a, _b;
         if (model.name.length === 0) {
-            throw new Error('unnamed model'); // TODO: this might no longer be an issue
+            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
         }
         const modelName = codegen.capitalize(model.name);
         let rustModel = this.types.get(modelName);
         if (rustModel) {
             return rustModel;
         }
+        // no stack means this is the first model in
+        // the chain of potentially recursive calls
+        if (!stack) {
+            stack = new Array();
+        }
+        stack.push(modelName);
         let modelFlags = rust.ModelFlags.Unspecified;
         if ((model.usage & tcgc.UsageFlags.Input) === tcgc.UsageFlags.Input) {
             modelFlags |= rust.ModelFlags.Input;
@@ -202,12 +223,13 @@ export class Adapter {
                     // we just adapt it here as a regular model field.
                 }
                 else {
-                    throw new Error(`model property kind ${property.kind} NYI`);
+                    throw new AdapterError('UnsupportedTsp', `model property kind ${property.kind} NYI`, (_b = property.__raw) === null || _b === void 0 ? void 0 : _b.node);
                 }
             }
-            const structField = this.getModelField(property, rustModel.visibility);
+            const structField = this.getModelField(property, rustModel.visibility, stack);
             rustModel.fields.push(structField);
         }
+        stack.pop();
         return rustModel;
     }
     /**
@@ -215,15 +237,19 @@ export class Adapter {
      *
      * @param property the tcgc model property to convert
      * @param modelVisibility the visibility of the model that contains the property
+     * @param stack is a stack of model type names used to detect recursive type definitions
      * @returns a Rust model field
      */
-    getModelField(property, modelVisibility) {
-        let fieldType = this.getType(property.type);
+    getModelField(property, modelVisibility, stack) {
+        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);
+        }
         // for public models each field is always an Option<T>.
-        // the only exception is for HashMap and Vec since an
-        // empty collection conveys the same semantics.
-        if ((modelVisibility === 'pub' || property.optional) && fieldType.kind !== 'hashmap' && fieldType.kind !== 'Vec') {
-            fieldType = new rust.Option(this.typeToWireType(fieldType));
+        if (modelVisibility === 'pub' || property.optional) {
+            fieldType = new rust.Option(fieldType.kind === 'box' ? fieldType : this.typeToWireType(fieldType));
         }
         const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), property.serializedName, modelVisibility, fieldType);
         modelField.docs = this.adaptDocs(property.summary, property.doc);
@@ -239,8 +265,15 @@ export class Adapter {
         }
         return modelField;
     }
-    /** converts a tcgc type to a Rust type */
-    getType(type) {
+    /**
+     * converts a tcgc type to a Rust type
+     *
+     * @param type the tcgc type to convert
+     * @param stack is a stack of model type names used to detect recursive type definitions
+     * @returns the adapted Rust type
+     */
+    getType(type, stack) {
+        var _a, _b;
         const getDateTimeEncoding = (encoding) => {
             switch (encoding) {
                 case 'rfc3339':
@@ -251,10 +284,6 @@ export class Adapter {
             }
         };
         const getScalar = (kind) => {
-            let scalar = this.types.get(kind);
-            if (scalar) {
-                return scalar;
-            }
             let scalarType;
             switch (kind) {
                 case 'boolean':
@@ -292,47 +321,32 @@ export class Adapter {
                     scalarType = 'u8';
                     break;
             }
-            scalar = new rust.Scalar(scalarType);
-            this.types.set(kind, scalar);
-            return scalar;
+            return this.getScalar(scalarType);
         };
         switch (type.kind) {
-            case 'array': {
-                const keyName = recursiveKeyName(type.kind, type.valueType);
-                let vectorType = this.types.get(keyName);
-                if (vectorType) {
-                    return vectorType;
-                }
-                vectorType = new rust.Vector(this.typeToWireType(this.getType(type.valueType)));
-                this.types.set(keyName, vectorType);
-                return vectorType;
-            }
+            case 'array':
+                return this.getVec(this.typeToWireType(this.getType(type.valueType, stack)));
             case 'bytes': {
                 let encoding = 'std';
                 if (type.encode === 'base64url') {
                     encoding = 'url';
                 }
-                const keyName = `encodedBytes-${encoding}`;
-                let encodedBytesType = this.types.get(keyName);
-                if (encodedBytesType) {
-                    return encodedBytesType;
-                }
-                encodedBytesType = new rust.EncodedBytes(encoding);
-                this.types.set(keyName, encodedBytesType);
-                return encodedBytesType;
+                return this.getEncodedBytes(encoding, false);
             }
             case 'constant':
                 return this.getLiteral(type);
-            case 'dict': {
-                const keyName = recursiveKeyName(type.kind, type.valueType);
-                let hashmapType = this.types.get(keyName);
-                if (hashmapType) {
-                    return hashmapType;
+            case 'decimal':
+            case 'decimal128': {
+                const keyName = 'decimal';
+                let decimalType = this.types.get(keyName);
+                if (!decimalType) {
+                    decimalType = new rust.Decimal(this.crate);
+                    this.types.set(keyName, decimalType);
                 }
-                hashmapType = new rust.HashMap(this.typeToWireType(this.getType(type.valueType)));
-                this.types.set(keyName, hashmapType);
-                return hashmapType;
+                return decimalType;
             }
+            case 'dict':
+                return this.getHashMap(this.typeToWireType(this.getType(type.valueType, stack)));
             case 'duration':
                 switch (type.wireType.kind) {
                     case 'float':
@@ -344,7 +358,7 @@ export class Adapter {
                     case 'string':
                         return this.getStringType();
                     default:
-                        throw new Error(`unhandled duration wireType.kind ${type.wireType.kind}`);
+                        throw new AdapterError('UnsupportedTsp', `unhandled duration wireType.kind ${type.wireType.kind}`, (_a = type.__raw) === null || _a === void 0 ? void 0 : _a.node);
                 }
             case 'boolean':
             case 'float32':
@@ -363,12 +377,12 @@ export class Adapter {
             case 'enumvalue':
                 return this.getEnumValue(type);
             case 'model':
-                return this.getModel(type);
+                return this.getModel(type, stack);
             case 'endpoint':
             case 'string':
             case 'url': {
                 if (type.kind === 'string' && type.crossLanguageDefinitionId === 'Azure.Core.eTag') {
-                    const etagKey = 'etag';
+                    const etagKey = 'Etag';
                     let etagType = this.types.get(etagKey);
                     if (etagType) {
                         return etagType;
@@ -379,39 +393,96 @@ export class Adapter {
                 }
                 return this.getStringType();
             }
+            case 'nullable':
+                // TODO: workaround until https://github.com/Azure/typespec-rust/issues/42 is fixed
+                return this.getType(type.type, stack);
             case 'offsetDateTime': {
-                const keyName = `${type.kind}-${type.encode}`;
+                const encoding = getDateTimeEncoding(type.encode);
+                const keyName = `offsetDateTime-${encoding}`;
                 let timeType = this.types.get(keyName);
                 if (timeType) {
                     return timeType;
                 }
-                timeType = new rust.OffsetDateTime(this.crate, getDateTimeEncoding(type.encode), false);
+                timeType = new rust.OffsetDateTime(this.crate, encoding, false);
                 this.types.set(keyName, timeType);
                 return timeType;
             }
             case 'unknown': {
-                let anyType = this.types.get(type.kind);
+                const keyName = 'jsonValue';
+                let anyType = this.types.get(keyName);
                 if (anyType) {
                     return anyType;
                 }
                 anyType = new rust.JsonValue(this.crate);
-                this.types.set(type.kind, anyType);
+                this.types.set(keyName, anyType);
                 return anyType;
             }
             case 'utcDateTime': {
-                const keyName = `${type.kind}-${type.encode}`;
+                const encoding = getDateTimeEncoding(type.encode);
+                const keyName = `offsetDateTime-${encoding}-utc`;
                 let timeType = this.types.get(keyName);
                 if (timeType) {
                     return timeType;
                 }
-                timeType = new rust.OffsetDateTime(this.crate, getDateTimeEncoding(type.encode), true);
+                timeType = new rust.OffsetDateTime(this.crate, encoding, true);
                 this.types.set(keyName, timeType);
                 return timeType;
             }
             default:
-                throw new Error(`unhandled tcgc type ${type.kind}`);
+                throw new AdapterError('UnsupportedTsp', `unhandled tcgc type ${type.kind}`, (_b = type.__raw) === null || _b === void 0 ? void 0 : _b.node);
         }
     }
+    /** returns an EncodedBytes type with the specified encoding */
+    getEncodedBytes(encoding, asSlice) {
+        const keyName = `encodedBytes-${encoding}${asSlice ? '-slice' : ''}`;
+        let encodedBytesType = this.types.get(keyName);
+        if (encodedBytesType) {
+            return encodedBytesType;
+        }
+        encodedBytesType = new rust.EncodedBytes(encoding, asSlice);
+        this.types.set(keyName, encodedBytesType);
+        return encodedBytesType;
+    }
+    /** returns a HashMap<String, type> */
+    getHashMap(type) {
+        const keyName = recursiveKeyName('hashmap', type);
+        let hashmapType = this.types.get(keyName);
+        if (hashmapType) {
+            return hashmapType;
+        }
+        hashmapType = new rust.HashMap(type);
+        this.types.set(keyName, hashmapType);
+        return hashmapType;
+    }
+    /** returns the specified type wrapped in a Ref */
+    getRefType(type) {
+        const typeKey = recursiveKeyName('ref', type);
+        let refType = this.types.get(typeKey);
+        if (!refType) {
+            refType = new rust.Ref(type);
+            this.types.set(typeKey, refType);
+        }
+        return refType;
+    }
+    /** returns a scalar for the specified scalar type */
+    getScalar(type) {
+        let scalar = this.types.get(type);
+        if (!scalar) {
+            scalar = new rust.Scalar(type);
+            this.types.set(type, scalar);
+        }
+        return scalar;
+    }
+    /** returns a slice of the specified type */
+    getSlice(type) {
+        const typeKey = recursiveKeyName('slice', type);
+        let slice = this.types.get(typeKey);
+        if (!slice) {
+            slice = new rust.Slice(type);
+            this.types.set(typeKey, slice);
+        }
+        return slice;
+    }
     /** returns the Rust string slice type */
     getStringSlice() {
         const typeKey = 'str';
@@ -445,6 +516,17 @@ export class Adapter {
         this.types.set(typeKey, unitType);
         return unitType;
     }
+    /** returns a Vec<type> */
+    getVec(type) {
+        const keyName = recursiveKeyName('Vec', type);
+        let vectorType = this.types.get(keyName);
+        if (vectorType) {
+            return vectorType;
+        }
+        vectorType = new rust.Vector(type);
+        this.types.set(keyName, vectorType);
+        return vectorType;
+    }
     /**
      * converts a tcgc constant to a Rust literal
      *
@@ -494,7 +576,7 @@ export class Adapter {
      * @returns a Rust client
      */
     recursiveAdaptClient(client, parent) {
-        var _a;
+        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')) {
@@ -561,7 +643,7 @@ export class Adapter {
                     }
                     default:
                         if (throwOnDefault) {
-                            throw new Error(`credential scheme type ${cred.type} NYI`);
+                            throw new AdapterError('UnsupportedTsp', `credential scheme type ${cred.type} NYI`);
                         }
                         return AuthTypes.Default;
                 }
@@ -585,7 +667,7 @@ export class Adapter {
                                 }
                                 // no supported credential types were specified
                                 if (authType === AuthTypes.Default) {
-                                    throw new Error(`credential scheme types ${variantKinds.join()} NYI`);
+                                    throw new AdapterError('UnsupportedTsp', `credential scheme types ${variantKinds.join()} NYI`, (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
                                 }
                                 continue;
                             }
@@ -613,7 +695,7 @@ export class Adapter {
                                 // 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.getStringSlice(), false, true);
+                                const adaptedParam = new rust.ClientMethodParameter(param.name, this.getRefType(this.getStringSlice()), false);
                                 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)));
@@ -642,9 +724,9 @@ export class Adapter {
                             }
                             const clientParam = this.adaptClientParameter(templateArg, rustClient.constructable);
                             if (clientParam.kind !== 'clientEndpoint') {
-                                throw new Error(`unexpected client parameter kind ${clientParam.kind}`);
+                                throw new AdapterError('InternalError', `unexpected client parameter kind ${clientParam.kind}`, (_b = templateArg.__raw) === null || _b === void 0 ? void 0 : _b.node);
                             }
-                            (_a = rustClient.constructable.endpoint) === null || _a === void 0 ? void 0 : _a.parameters.push(clientParam);
+                            (_c = rustClient.constructable.endpoint) === null || _c === void 0 ? void 0 : _c.parameters.push(clientParam);
                             ctorParams.push(clientParam);
                         }
                         break;
@@ -691,7 +773,7 @@ export class Adapter {
             }
         }
         else {
-            throw new Error(`uninstantiable client ${client.name} has no parent`);
+            throw new AdapterError('InternalError', `uninstantiable client ${client.name} has no parent`);
         }
         for (const child of values(client.children)) {
             const subClient = this.recursiveAdaptClient(child, rustClient);
@@ -705,7 +787,7 @@ export class Adapter {
                     code: 'LroNotSupported',
                     severity: 'warning',
                     message: `skip emitting LRO ${method.name}`,
-                    target: method.__raw ? method.__raw.node : NoTarget,
+                    target: (_e = (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node) !== null && _e !== void 0 ? _e : NoTarget,
                 });
                 continue;
             }
@@ -723,12 +805,15 @@ export class Adapter {
      */
     createTokenCredentialCtor(rustClient, cred) {
         if (cred.flows.length === 0) {
-            throw new Error(`no flows defined for credential type ${cred.type}`);
+            throw new AdapterError('InternalError', `no flows defined for credential type ${cred.type}`, cred.model);
         }
         const scopes = new Array();
         for (const scope of cred.flows[0].scopes) {
             scopes.push(scope.value);
         }
+        if (scopes.length === 0) {
+            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);
         tokenCredParam.docs.summary = `An implementation of [\`TokenCredential\`](azure_core::credentials::TokenCredential) that can provide an Entra ID token to use when authenticating.`;
@@ -744,10 +829,11 @@ export class Adapter {
      * @returns the Rust client parameter
      */
     adaptClientParameter(param, constructable) {
+        var _a;
         let paramType;
         if (param.isApiVersionParam) {
             if (!param.clientDefaultValue) {
-                throw new Error(`API version parameter ${param.name} has no clientDefaultValue`);
+                throw new AdapterError('InternalError', `API version parameter ${param.name} has no clientDefaultValue`, (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
             }
             paramType = this.getStringType();
         }
@@ -816,6 +902,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;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = codegen.deconstruct(srcMethodName);
@@ -826,11 +913,11 @@ export class Adapter {
                 code: 'PagingMethodRename',
                 severity: 'warning',
                 message: `renamed paging method from ${method.name} to ${srcMethodName}`,
-                target: method.__raw ? method.__raw.node : NoTarget,
+                target: (_b = (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : NoTarget,
             });
         }
         else if (this.renamedMethods.has(srcMethodName)) {
-            throw new Error(`method name ${srcMethodName} collides with a renamed method`);
+            throw new AdapterError('NameCollision', `method name ${srcMethodName} collides with a renamed method`, (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node);
         }
         const methodName = naming.getEscapedReservedName(snakeCaseName(srcMethodName), 'fn');
         const optionsLifetime = new rust.Lifetime('a');
@@ -865,7 +952,7 @@ export class Adapter {
                 rustMethod = new rust.PageableMethod(methodName, rustClient, pub, methodOptions, httpMethod, httpPath);
                 break;
             default:
-                throw new Error(`method kind ${method.kind} NYI`);
+                throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
         }
         rustMethod.docs = this.adaptDocs(method.summary, method.doc);
         rustClient.methods.push(rustMethod);
@@ -875,6 +962,8 @@ export class Adapter {
         if (method.operation.bodyParam) {
             allOpParams.push(method.operation.bodyParam);
         }
+        // maps tcgc method header/query params to their Rust method params
+        const paramsMap = new Map();
         for (const param of method.parameters) {
             // we need to translate from the method param to its underlying operation param.
             // most params have a one-to-one mapping. however, for spread params, there will
@@ -886,7 +975,7 @@ export class Adapter {
                 }).any();
             }).first();
             if (!opParam) {
-                throw new Error(`didn't find operation parameter for method ${method.name} parameter ${param.name}`);
+                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_e = param.__raw) === null || _e === void 0 ? void 0 : _e.node);
             }
             let adaptedParam;
             // for spread params there are two cases we need to consider.
@@ -900,6 +989,9 @@ export class Adapter {
             else {
                 adaptedParam = this.adaptMethodParameter(opParam);
             }
+            if (adaptedParam.kind === 'header' || adaptedParam.kind === 'query') {
+                paramsMap.set(param, adaptedParam);
+            }
             adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
             rustMethod.params.push(adaptedParam);
             if (adaptedParam.optional) {
@@ -911,18 +1003,11 @@ export class Adapter {
                     // already wrapped in an Option<T> type.
                     const field = adaptedParam.type.content.type.fields.find(f => { return f.name === adaptedParam.name; });
                     if (!field) {
-                        throw new Error(`didn't find spread param field ${adaptedParam.name} in type ${adaptedParam.type.content.type.name}`);
+                        throw new AdapterError('InternalError', `didn't find spread param field ${adaptedParam.name} in type ${adaptedParam.type.content.type.name}`);
                     }
                     fieldType = field.type;
                 }
                 else {
-                    switch (adaptedParam.type.kind) {
-                        case 'requestContent':
-                        case 'struct':
-                            break;
-                        default:
-                            adaptedParam.type = this.typeToWireType(adaptedParam.type);
-                    }
                     fieldType = new rust.Option(adaptedParam.type);
                 }
                 const optionsField = new rust.StructField(adaptedParam.name, 'pub', fieldType);
@@ -940,17 +1025,18 @@ export class Adapter {
             }
         }
         const getBodyFormat = () => {
+            var _a, _b;
             // fetch the body format from the HTTP responses.
             // they should all have the same type so no need to match responses to type.
             let defaultContentType;
             for (const httpResp of method.operation.responses) {
                 if (defaultContentType && httpResp.defaultContentType && defaultContentType !== httpResp.defaultContentType) {
-                    throw new Error(`method ${method.name} has conflicting content types`);
+                    throw new AdapterError('InternalError', `method ${method.name} has conflicting content types`, (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
                 }
                 defaultContentType = httpResp.defaultContentType;
             }
             if (!defaultContentType) {
-                throw new Error(`unable to determine content type for method ${method.name}`);
+                throw new AdapterError('InternalError', `unable to determine content type for method ${method.name}`, (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
             }
             return this.adaptBodyFormat(defaultContentType);
         };
@@ -980,16 +1066,53 @@ export class Adapter {
             // however, we want the synthesized paged response envelope type instead.
             const synthesizedType = method.operation.responses[0].type;
             if (!synthesizedType) {
-                throw new Error(`paged method ${method.name} has no synthesized response type`);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node);
             }
             else if (synthesizedType.kind !== 'model') {
-                throw new Error(`paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`);
+                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
             }
             const format = getBodyFormat();
-            const synthesizedModel = this.getModel(synthesizedType);
+            const synthesizedModel = this.getModel(synthesizedType, new Array());
             if (!this.crate.models.includes(synthesizedModel)) {
                 this.crate.models.push(synthesizedModel);
             }
+            // for the pager response type, remove the Option<T> around the Vec<T> for the page items
+            if (!method.pagingMetadata.pageItemsSegments) {
+                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
+            }
+            // unwrap all of the segments for the paged response
+            let unwrappedCount = 0;
+            let typeToUnwrap = synthesizedModel;
+            for (const pageItemsSegment of method.pagingMetadata.pageItemsSegments) {
+                const segment = pageItemsSegment;
+                let serde;
+                switch (format) {
+                    case 'json':
+                        serde = segment.serializationOptions.json.name;
+                        break;
+                    case 'xml':
+                        serde = segment.serializationOptions.xml.name;
+                        break;
+                }
+                for (let i = 0; i < typeToUnwrap.fields.length; ++i) {
+                    const field = typeToUnwrap.fields[i];
+                    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;
+                        }
+                        // move to the next segment
+                        if (field.type.kind === 'model') {
+                            typeToUnwrap = field.type;
+                        }
+                        ++unwrappedCount;
+                        break;
+                    }
+                }
+            }
+            if (unwrappedCount !== method.pagingMetadata.pageItemsSegments.length) {
+                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
+            }
             returnType = new rust.Pager(this.crate, new rust.Payload(synthesizedModel, format));
         }
         else if (method.response.type && !(method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes')) {
@@ -1011,14 +1134,42 @@ export class Adapter {
             returnType = new rust.Response(this.crate, this.getUnitType());
         }
         rustMethod.returns = new rust.Result(this.crate, returnType);
-        rustMethod.responseHeaders = this.adaptResponseHeadersTrait(rustClient, rustMethod, responseHeaders);
+        const responseHeadersMap = this.adaptResposeHeaders(responseHeaders);
+        rustMethod.responseHeaders = this.adaptResponseHeadersTrait(rustClient, rustMethod, Array.from(responseHeadersMap.values()));
         if (method.kind === 'paging') {
             // can't do this until the method has been completely adapted
-            rustMethod.strategy = this.adaptPageableMethodStrategy(method);
+            rustMethod.strategy = this.adaptPageableMethodStrategy(method, paramsMap, responseHeadersMap);
+        }
+    }
+    /**
+     * adapts response headers into Rust response headers and provides
+     * a mapping from the tcgc response header to the Rust equivalent.
+     * if there are no headers to adapt, an empty map is returned.
+     *
+     * @param responseHeaders the response headers to adapt (can be empty)
+     * @returns the map of response headers
+     */
+    adaptResposeHeaders(responseHeaders) {
+        const responseHeadersMap = new Map();
+        // adapt the response headers and add them to the trait
+        for (const header of responseHeaders) {
+            let responseHeader;
+            if (header.type.kind === 'dict') {
+                if (header.serializedName !== 'x-ms-meta' && header.serializedName !== 'x-ms-or') {
+                    throw new AdapterError('InternalError', `unexpected response header collection ${header.serializedName}`, header.__raw.node);
+                }
+                responseHeader = new rust.ResponseHeaderHashMap(snakeCaseName(header.name), header.serializedName);
+            }
+            else {
+                responseHeader = new rust.ResponseHeaderScalar(snakeCaseName(header.name), fixETagName(header.serializedName), this.typeToWireType(this.getType(header.type)));
+            }
+            responseHeader.docs = this.adaptDocs(header.summary, header.doc);
+            responseHeadersMap.set(header, responseHeader);
         }
+        return responseHeadersMap;
     }
     /**
-     * adapts response headers into a Rust ResponseHeadersTrait
+     * creates a Rust ResponseHeadersTrait for the specified response headers.
      * if there are no response headers, undefined is returned.
      *
      * @param client the client that contains the method
@@ -1030,6 +1181,32 @@ export class Adapter {
         if (responseHeaders.length === 0) {
             return undefined;
         }
+        /**
+         * recursively builds a name from the specified type.
+         * e.g. Vec<FooModel> would be VecFooModel etc.
+         *
+         * @param type the type for which to build a name
+         * @returns the name
+         */
+        const recursiveTypeName = function (type) {
+            switch (type.kind) {
+                case 'enum':
+                case 'model':
+                    return type.name;
+                case 'hashmap':
+                    return `${type.name}${recursiveTypeName(type.type)}`;
+                case 'ref':
+                    return `Ref${recursiveTypeName(type.type)}`;
+                case 'scalar':
+                    return codegen.capitalize(type.type);
+                case 'slice':
+                    return `Slice${recursiveTypeName(type.type)}`;
+                case 'Vec':
+                    return `${type.kind}${recursiveTypeName(type.type)}`;
+                default:
+                    return codegen.capitalize(type.kind);
+            }
+        };
         // response header traits are only ever for marker types and payloads
         let implFor;
         switch (method.returns.type.kind) {
@@ -1038,13 +1215,13 @@ export class Adapter {
                 break;
             case 'response':
                 if (method.returns.type.content.kind !== 'marker' && method.returns.type.content.kind !== 'payload') {
-                    throw new Error(`unexpected method content kind ${method.returns.type.content.kind}`);
+                    throw new AdapterError('InternalError', `unexpected method content kind ${method.returns.type.content.kind}`);
                 }
                 implFor = method.returns.type.content;
                 break;
             default:
                 // this is Unit which should have been previously skipped
-                throw new Error(`unexpected method return kind ${method.returns.type.kind}`);
+                throw new AdapterError('InternalError', `unexpected method return kind ${method.returns.type.kind}`);
         }
         let traitName;
         switch (implFor.kind) {
@@ -1052,83 +1229,99 @@ export class Adapter {
                 traitName = implFor.name;
                 break;
             case 'payload':
-                traitName = this.recursiveTypeName(implFor.type);
+                traitName = recursiveTypeName(implFor.type);
                 break;
         }
         traitName += 'Headers';
         // NOTE: the complete doc text will be emitted at codegen time
         const docs = this.asDocLink(`${client.name}::${method.name}()`, `crate::generated::clients::${client.name}::${method.name}()`);
         const responseHeadersTrait = new rust.ResponseHeadersTrait(traitName, implFor, docs);
-        // adapt the response headers and add them to the trait
-        for (const header of responseHeaders) {
-            let responseHeader;
-            if (header.type.kind === 'dict') {
-                if (header.serializedName !== 'x-ms-meta' && header.serializedName !== 'x-ms-or') {
-                    throw new Error(`unexpected response header collection ${header.serializedName}`);
-                }
-                responseHeader = new rust.ResponseHeaderHashMap(snakeCaseName(header.name), header.serializedName);
-            }
-            else {
-                responseHeader = new rust.ResponseHeaderScalar(snakeCaseName(header.name), fixETagName(header.serializedName), this.getType(header.type));
-            }
-            responseHeader.docs = this.adaptDocs(header.summary, header.doc);
-            responseHeadersTrait.headers.push(responseHeader);
-        }
+        responseHeadersTrait.headers.push(...responseHeaders);
         return responseHeadersTrait;
     }
-    /**
-     * recursively builds a name from the specified type.
-     * e.g. Vec<FooModel> would be VecFooModel etc.
-     *
-     * @param type the type for which to build a name
-     * @returns the name
-     */
-    recursiveTypeName(type) {
-        switch (type.kind) {
-            case 'enum':
-            case 'model':
-                return type.name;
-            case 'hashmap':
-                return `${type.name}${this.recursiveTypeName(type.type)}`;
-            case 'Vec':
-                return `${type.kind}${this.recursiveTypeName(type.type)}`;
-            default:
-                return codegen.capitalize(type.kind);
-        }
-    }
     /**
      * creates the pageable strategy based on the method definition
      *
      * @param method the pageable method for which to create a strategy
+     * @param paramsMap maps tcgc method params to Rust params (needed for continuation token strategy)
+     * @param respHeadersMap maps tcgc response headers to Rust response headers (needed for continuation token strategy)
      * @returns the pageable strategy
      */
-    adaptPageableMethodStrategy(method) {
+    adaptPageableMethodStrategy(method, paramsMap, respHeadersMap) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         if (method.pagingMetadata.nextLinkOperation) {
             // TODO: https://github.com/Azure/autorest.rust/issues/103
-            throw new Error('next page operation NYI');
+            throw new AdapterError('UnsupportedTsp', 'next page operation NYI', (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
         }
         else if (method.pagingMetadata.nextLinkSegments) {
             if (method.pagingMetadata.nextLinkSegments.length > 1) {
                 // TODO: https://github.com/Azure/autorest.rust/issues/102
-                throw new Error('nested next link path NYI');
+                throw new AdapterError('UnsupportedTsp', 'nested next link path NYI', (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
             }
             // this is the field in the response type that contains the next link URL
             const nextLinkSegment = method.pagingMetadata.nextLinkSegments[0];
             if (nextLinkSegment.kind !== 'property') {
-                throw new Error(`unexpected kind ${nextLinkSegment.kind} for next link segment in operation ${method.name}`);
+                throw new AdapterError('InternalError', `unexpected kind ${nextLinkSegment.kind} for next link segment in operation ${method.name}`, (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node);
             }
             const nextLinkField = this.fieldsMap.get(nextLinkSegment);
             if (!nextLinkField) {
                 // the most likely explanation for this is lack of reference equality
-                throw new Error(`missing next link field name ${nextLinkSegment.name} for operation ${method.name}`);
+                throw new AdapterError('InternalError', `missing next link field name ${nextLinkSegment.name} for operation ${method.name}`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
             }
             return new rust.PageableStrategyNextLink(nextLinkField);
         }
         else if (method.pagingMetadata.continuationTokenParameterSegments && method.pagingMetadata.continuationTokenResponseSegments) {
-            throw new Error('PageableStrategyContinuationToken NYI');
+            if (method.pagingMetadata.continuationTokenParameterSegments.length > 1) {
+                throw new AdapterError('UnsupportedTsp', `nested continuationTokenParameterSegments NYI`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
+            }
+            if (method.pagingMetadata.continuationTokenResponseSegments.length > 1) {
+                throw new AdapterError('UnsupportedTsp', `nested continuationTokenResponseSegments NYI`, (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node);
+            }
+            const tokenReq = method.pagingMetadata.continuationTokenParameterSegments[0];
+            const tokenResp = method.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 ${tokenResp.name} for operation ${method.name}`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                    }
+                    requestToken = tokenParam;
+                    break;
+                }
+                default:
+                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, (_h = tokenReq.__raw) === null || _h === void 0 ? void 0 : _h.node);
+            }
+            // find the continuation token response
+            let responseToken;
+            switch (tokenResp.kind) {
+                case 'property': {
+                    const tokenField = this.fieldsMap.get(tokenResp);
+                    if (!tokenField) {
+                        throw new AdapterError('InternalError', `missing continuation token response field name ${tokenResp.name} for operation ${method.name}`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
+                    }
+                    responseToken = tokenField;
+                    break;
+                }
+                case 'responseheader': {
+                    const tokenHeader = respHeadersMap.get(tokenResp);
+                    if (!tokenHeader) {
+                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${method.name}`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
+                    }
+                    if (tokenHeader.kind !== 'responseHeaderScalar') {
+                        throw new AdapterError('InternalError', `unexpected response header kind ${tokenHeader.kind}`);
+                    }
+                    responseToken = tokenHeader;
+                    break;
+                }
+                default:
+                    throw new AdapterError('InternalError', `unhandled continuationTokenResponseSegment kind ${tokenResp.kind}`);
+            }
+            return new rust.PageableStrategyContinuationToken(requestToken, responseToken);
         }
         else {
-            throw new Error(`unhandled paging strategy for operation ${method.name}`);
+            throw new AdapterError('InternalError', `unknown paging strategy for operation ${method.name}`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
         }
     }
     /**
@@ -1138,6 +1331,7 @@ export class Adapter {
      * @returns a Rust method parameter
      */
     adaptMethodParameter(param) {
+        var _a, _b, _c, _d, _e;
         const paramLoc = param.onClient ? 'client' : 'method';
         /**
          * used to create keys for this.clientMethodParams
@@ -1158,11 +1352,12 @@ export class Adapter {
         }
         const paramName = naming.getEscapedReservedName(snakeCaseName(param.name), 'param');
         let paramType = this.getType(param.type);
-        let paramByRef = false;
-        // for required header/path/query method string params, we emit them as &str instead of String
-        if (!param.optional && !param.onClient && paramType.kind === 'String' && (param.kind === 'header' || param.kind === 'path' || param.kind === 'query')) {
-            paramType = this.getStringSlice();
-            paramByRef = true;
+        // for required header/path/query method string params, we might emit them as borrowed types
+        if (!param.optional && !param.onClient && (param.kind === 'header' || param.kind === 'path' || param.kind === 'query')) {
+            const borrowedType = this.canBorrowMethodParam(paramType, param.kind);
+            if (borrowedType) {
+                paramType = borrowedType;
+            }
         }
         let adaptedParam;
         switch (param.kind) {
@@ -1180,11 +1375,11 @@ export class Adapter {
             }
             case 'cookie':
                 // TODO: https://github.com/Azure/typespec-rust/issues/192
-                throw new Error('cookie parameters are not supported');
+                throw new AdapterError('UnsupportedTsp', 'cookie parameters are not supported', (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
             case 'header':
                 if (param.collectionFormat) {
-                    if (paramType.kind !== 'Vec') {
-                        throw new Error(`unexpected kind ${paramType.kind} for HeaderCollectionParameter`);
+                    if (paramType.kind !== 'Vec' && !isRefSlice(paramType)) {
+                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for HeaderCollectionParameter`, (_b = param.__raw) === null || _b === void 0 ? void 0 : _b.node);
                     }
                     let format;
                     switch (param.collectionFormat) {
@@ -1198,47 +1393,91 @@ export class Adapter {
                             format = param.collectionFormat;
                             break;
                         default:
-                            throw new Error(`unexpected format ${param.collectionFormat} for HeaderCollectionParameter`);
+                            throw new AdapterError('InternalError', `unexpected format ${param.collectionFormat} for HeaderCollectionParameter`, (_c = param.__raw) === null || _c === void 0 ? void 0 : _c.node);
                     }
                     adaptedParam = new rust.HeaderCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, format);
                 }
                 else if (param.serializedName === 'x-ms-meta') {
                     if (paramType.kind !== 'hashmap') {
-                        throw new Error(`unexpected kind ${paramType.kind} for header ${param.serializedName}`);
+                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for header ${param.serializedName}`, (_d = param.__raw) === null || _d === void 0 ? void 0 : _d.node);
                     }
                     adaptedParam = new rust.HeaderHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
                 }
                 else {
-                    adaptedParam = new rust.HeaderParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
+                    adaptedParam = new rust.HeaderParameter(paramName, param.serializedName, paramLoc, param.optional, this.typeToWireType(paramType));
                     adaptedParam.isApiVersion = param.isApiVersionParam;
                 }
                 break;
             case 'path':
-                adaptedParam = new rust.PathParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved);
+                adaptedParam = new rust.PathParameter(paramName, param.serializedName, paramLoc, param.optional, this.typeToWireType(paramType), param.allowReserved);
                 break;
             case 'query':
                 if (param.collectionFormat) {
                     const format = param.collectionFormat === 'simple' ? 'csv' : (param.collectionFormat === 'form' ? 'multi' : param.collectionFormat);
-                    if (paramType.kind !== 'Vec') {
-                        throw new Error(`unexpected kind ${paramType.kind} for QueryCollectionParameter`);
+                    if (paramType.kind !== 'Vec' && !isRefSlice(paramType)) {
+                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for QueryCollectionParameter`, (_e = param.__raw) === null || _e === void 0 ? void 0 : _e.node);
                     }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
                     adaptedParam = new rust.QueryCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true, format);
                 }
                 else {
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true);
+                    adaptedParam = new rust.QueryParameter(paramName, param.serializedName, paramLoc, param.optional, this.typeToWireType(paramType), true);
                     adaptedParam.isApiVersion = param.isApiVersionParam;
                 }
                 break;
         }
         adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
-        adaptedParam.ref = paramByRef;
         if (paramLoc === 'client') {
             this.clientMethodParams.set(getClientParamsKey(param), adaptedParam);
         }
         return adaptedParam;
     }
+    /**
+     * updates the specified type to a borrowed type based on its type and kind.
+     * if no such transformation is necessary, undefined is returned.
+     * e.g. a String param that doesn't need to be owned will be
+     * returned as a &str.
+     *
+     * @param type the param type to be updated
+     * @param kind the kind of param
+     * @returns the updated param type or undefined
+     */
+    canBorrowMethodParam(type, kind) {
+        const recursiveBuildVecStr = (v) => {
+            switch (v.kind) {
+                case 'encodedBytes':
+                    return this.getRefType(this.getEncodedBytes(v.encoding, true));
+                case 'hashmap':
+                    return this.getHashMap(this.typeToWireType(recursiveBuildVecStr(v.type)));
+                case 'String':
+                    return this.getRefType(this.getStringSlice());
+                case 'Vec':
+                    return this.getVec(this.typeToWireType(recursiveBuildVecStr(v.type)));
+                default:
+                    throw new AdapterError('InternalError', `unexpected kind ${v.kind}`);
+            }
+        };
+        switch (type.kind) {
+            case 'String':
+                // header String params are always owned
+                if (kind !== 'header') {
+                    return this.getRefType(this.getStringSlice());
+                }
+                break;
+            case 'Vec': {
+                // if this is an array of string, we ultimately want a slice of &str
+                const unwrapped = helpers.unwrapVec(type);
+                if (unwrapped.kind === 'String' || unwrapped.kind === 'encodedBytes') {
+                    return this.getRefType(this.getSlice(recursiveBuildVecStr(type.type)));
+                }
+                return this.getRefType(this.getSlice(type.type));
+            }
+            case 'encodedBytes':
+                return this.getRefType(this.getEncodedBytes(type.encoding, true));
+        }
+        return undefined;
+    }
     /**
      * narrows a rust.Type to a rust.WireType.
      * if type isn't a rust.WireType, an error is thrown.
@@ -1249,6 +1488,7 @@ export class Adapter {
     typeToWireType(type) {
         switch (type.kind) {
             case 'bytes':
+            case 'decimal':
             case 'encodedBytes':
             case 'enum':
             case 'enumValue':
@@ -1258,14 +1498,16 @@ export class Adapter {
             case 'literal':
             case 'model':
             case 'offsetDateTime':
+            case 'ref':
             case 'scalar':
+            case 'slice':
             case 'str':
             case 'String':
             case 'Url':
             case 'Vec':
                 return type;
             default:
-                throw new Error(`cannot convert ${type.kind} to a wire type`);
+                throw new AdapterError('InternalError', `cannot convert ${type.kind} to a wire type`);
         }
     }
     /**
@@ -1277,6 +1519,7 @@ export class Adapter {
      * @returns a Rust partial body parameter
      */
     adaptMethodSpreadParameter(param, format, opParamType) {
+        var _a, _b;
         switch (format) {
             case 'json':
             case 'xml': {
@@ -1289,27 +1532,16 @@ export class Adapter {
                     }
                 }
                 if (serializedName === undefined) {
-                    throw new Error(`didn't find body model property for spread parameter ${param.name}`);
-                }
-                // this is the param type as surfaced in the method sig.
-                // it's usually the same type as its corresponding field type
-                // in the underlying model. the only exception is for String
-                // types. we want to surface those as &str in the method sig.
-                let paramType = this.getType(param.type);
-                let paramByRef = false;
-                if (!param.optional && !param.onClient && paramType.kind === 'String') {
-                    paramType = this.getStringSlice();
-                    paramByRef = true;
+                    throw new AdapterError('InternalError', `didn't find body model property for spread parameter ${param.name}`, (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
                 }
                 // this is the internal model type that the spread params coalesce into
                 const payloadType = this.getType(opParamType);
                 if (payloadType.kind !== 'model') {
-                    throw new Error(`unexpected kind ${payloadType.kind} for spread body param`);
+                    throw new AdapterError('InternalError', `unexpected kind ${payloadType.kind} for spread body param`, (_b = opParamType.__raw) === null || _b === void 0 ? void 0 : _b.node);
                 }
                 const paramName = naming.getEscapedReservedName(snakeCaseName(param.name), 'param');
                 const paramLoc = 'method';
-                const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, paramType, new rust.RequestContent(this.crate, new rust.Payload(payloadType, format)));
-                adaptedParam.ref = paramByRef;
+                const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, this.getType(param.type), new rust.RequestContent(this.crate, new rust.Payload(payloadType, format)));
                 return adaptedParam;
             }
         }
@@ -1332,10 +1564,14 @@ export class Adapter {
             return 'xml';
         }
         else {
-            throw new Error(`unexpected contentType ${contentType}`);
+            throw new AdapterError('InternalError', `unexpected contentType ${contentType}`);
         }
     }
 }
+/** typeguard to determine if type is a Ref<Slice> */
+function isRefSlice(type) {
+    return type.kind === 'ref' && type.type.kind === 'slice';
+}
 /**
  * transforms Etag etc to all lower case.
  * this is to prevent inadvertently snake-casing
@@ -1366,41 +1602,36 @@ function snakeCaseName(name) {
  *
  * obj 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 dict-array-int32.
+ * unwrap to hashmap-Vec-i32.
  *
  * @param root the starting value for the key
  * @param obj the type for which to create the key
  * @returns a string containing the complete map key
  */
-function recursiveKeyName(root, obj) {
-    switch (obj.kind) {
-        case 'array':
-            return recursiveKeyName(`${root}-array`, obj.valueType);
-        case 'bytes':
-            return `${root}-bytes-${obj.encode ? obj.encode : 'std'}`;
+function recursiveKeyName(root, type) {
+    switch (type.kind) {
+        case 'Vec':
+            return recursiveKeyName(`${root}-${type.kind}`, type.type);
+        case 'encodedBytes':
+            return `${root}-${type.kind}-${type.encoding}${type.slice ? '-slice' : ''}`;
         case 'enum':
-            return `${root}-${obj.name}`;
-        case 'enumvalue':
-            return `${root}-${obj.enumType.name}-${obj.value}`;
-        case 'dict':
-            return recursiveKeyName(`${root}-dict`, obj.valueType);
-        case 'plainDate':
-            return `${root}-plainDate`;
-        case 'utcDateTime':
-            return `${root}-${obj.encode}`;
-        case 'duration':
-            // TODO: this should be: return `${root}-duration-${obj.encode}`;
-            // as it is now, it treats the duration as a String
-            // https://github.com/Azure/typespec-rust/issues/41
-            return `${root}-${obj.wireType.kind}`;
+            return `${root}-${type.kind}-${type.name}`;
+        case 'enumValue':
+            return `${root}-${type.type.name}-${type.name}`;
+        case 'hashmap':
+            return recursiveKeyName(`${root}-${type.kind}`, type.type);
+        case 'offsetDateTime':
+            return `${root}-${type.kind}-${type.encoding}${type.utc ? '-utc' : ''}`;
         case 'model':
-            return `${root}-${obj.name}`;
-        case 'nullable':
-            return recursiveKeyName(root, obj.type);
-        case 'plainTime':
-            return `${root}-plainTime`;
+            return `${root}-${type.kind}-${type.name}`;
+        case 'ref':
+            return recursiveKeyName(`${root}-${type.kind}`, type.type);
+        case 'scalar':
+            return `${root}-${type.kind}-${type.type}`;
+        case 'slice':
+            return recursiveKeyName(`${root}-${type.kind}`, type.type);
         default:
-            return `${root}-${obj.kind}`;
+            return `${root}-${type.kind}`;
     }
 }
 /**