@azure-tools/typespec-rust 0.13.0 → 0.13.2

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

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/tcgcadapter/adapter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAyB,WAAW,EAAY,MAAM,oBAAoB,CAAC;AAIlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C,2DAA2D;AAC3D,qBAAa,OAAO;IAClB;;;;;OAKG;WACU,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAY/E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IAGtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAG/C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoC;IAGvE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;IAE7C,OAAO;IAcP,wDAAwD;IACxD,WAAW,IAAI,IAAI,CAAC,KAAK;IAgCzB,gDAAgD;IAChD,OAAO,CAAC,SAAS;IAajB,4DAA4D;IAC5D,OAAO,CAAC,UAAU;IAuBlB;;;;;OAKG;IACH,OAAO,CAAC,OAAO;IAoBf;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAWpB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAkEhB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAuBrB,0CAA0C;IAC1C,OAAO,CAAC,OAAO;IAkLf,yCAAyC;IACzC,OAAO,CAAC,cAAc;IAUtB,mCAAmC;IACnC,OAAO,CAAC,aAAa;IAWrB,iCAAiC;IACjC,OAAO,CAAC,WAAW;IAWnB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAWlB,4EAA4E;IAC5E,OAAO,CAAC,YAAY;IAcpB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAmO5B;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAgBjC;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAuC5B;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAkOnB;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IA2G5B;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IA2ClC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAaxB"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/tcgcadapter/adapter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAyB,WAAW,EAAY,MAAM,oBAAoB,CAAC;AAIlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C,2DAA2D;AAC3D,qBAAa,OAAO;IAClB;;;;;OAKG;WACU,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAY/E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAG7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAG/C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoC;IAGvE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;IAG7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8E;IAExG,OAAO;IAgBP,wDAAwD;IACxD,WAAW,IAAI,IAAI,CAAC,KAAK;IAiCzB,gDAAgD;IAChD,OAAO,CAAC,SAAS;IAajB,4DAA4D;IAC5D,OAAO,CAAC,UAAU;IAuBlB;;;;;OAKG;IACH,OAAO,CAAC,OAAO;IAoBf;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAWpB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAkEhB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IA4BrB,0CAA0C;IAC1C,OAAO,CAAC,OAAO;IAkLf,yCAAyC;IACzC,OAAO,CAAC,cAAc;IAUtB,mCAAmC;IACnC,OAAO,CAAC,aAAa;IAWrB,iCAAiC;IACjC,OAAO,CAAC,WAAW;IAWnB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAWlB,4EAA4E;IAC5E,OAAO,CAAC,YAAY;IASpB;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IAOjB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IA+O5B;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAgBjC;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAwC5B;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAyNnB;;;;;;;;OAQG;IACH,OAAO,CAAC,yBAAyB;IAuDjC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,2BAA2B;IA6BnC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IA2G5B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAuBtB;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IA2ClC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAaxB"}

package/dist/src/tcgcadapter/adapter.js

@@ -32,18 +32,21 @@ export class Adapter {
         this.types = new Map();
         this.clientMethodParams = new Map();
         this.renamedMethods = new Set();
+        this.fieldsMap = new Map();
         this.ctx = ctx;
+        this.options = options;
         let serviceType = 'data-plane';
         if (this.ctx.arm === true) {
             serviceType = 'azure-arm';
         }
-        this.crate = new rust.Crate(options['crate-name'], options['crate-version'], serviceType);
+        this.crate = new rust.Crate(this.options['crate-name'], this.options['crate-version'], serviceType);
     }
     /** performs all the steps to convert tcgc to a crate */
     tcgcToCrate() {
         this.adaptTypes();
         this.adaptClients();
-        if (this.crate.enums.length > 0 || this.crate.models.length > 0) {
+        // marker models don't require serde so exclude them from the check
+        if (this.crate.enums.length > 0 || values(this.crate.models).where(e => e.kind === 'model').any()) {
             this.crate.addDependency(new rust.CrateDependency('serde'));
         }
         if (this.crate.clients.length > 0 || this.crate.enums.length > 0 || this.crate.models.length > 0) {
@@ -220,7 +223,7 @@ export class Adapter {
         // 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(fieldType);
+            fieldType = new rust.Option(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);
@@ -230,6 +233,10 @@ export class Adapter {
             modelField.serde = xmlName;
         }
         modelField.xmlKind = getXMLKind(property.decorators, modelField);
+        // it's possible for different models to reference the same property definition
+        if (!this.fieldsMap.get(property)) {
+            this.fieldsMap.set(property, modelField);
+        }
         return modelField;
     }
     /** converts a tcgc type to a Rust type */
@@ -296,7 +303,7 @@ export class Adapter {
                 if (vectorType) {
                     return vectorType;
                 }
-                vectorType = new rust.Vector(this.getType(type.valueType));
+                vectorType = new rust.Vector(this.typeToWireType(this.getType(type.valueType)));
                 this.types.set(keyName, vectorType);
                 return vectorType;
             }
@@ -322,7 +329,7 @@ export class Adapter {
                 if (hashmapType) {
                     return hashmapType;
                 }
-                hashmapType = new rust.HashMap(this.getType(type.valueType));
+                hashmapType = new rust.HashMap(this.typeToWireType(this.getType(type.valueType)));
                 this.types.set(keyName, hashmapType);
                 return hashmapType;
             }
@@ -457,16 +464,27 @@ export class Adapter {
     /** converts all tcgc clients and their methods into Rust clients/methods */
     adaptClients() {
         for (const client of this.ctx.sdkPackage.clients) {
-            if (client.methods.length === 0) {
-                // skip generating empty clients
-                continue;
-            }
             // start with instantiable clients and recursively work down
             if (client.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
                 this.recursiveAdaptClient(client);
             }
         }
     }
+    /**
+     * formats input as a doc link.
+     * e.g. [`${id}`](${link})
+     * if doc links are disabled, id is returned
+     *
+     * @param id the ID of the doc link
+     * @param link the target of the doc link
+     * @returns the doc link or id
+     */
+    asDocLink(id, link) {
+        if (this.options['temp-omit-doc-links'] === true) {
+            return `\`${id}\``;
+        }
+        return `[\`${id}\`](${link})`;
+    }
     /**
      * recursively converts a client and its methods.
      * this simplifies the case for hierarchical clients.
@@ -502,15 +520,16 @@ export class Adapter {
         const rustClient = new rust.Client(clientName);
         rustClient.docs = this.adaptDocs(client.summary, client.doc);
         rustClient.parent = parent;
-        rustClient.fields.push(new rust.StructField('pipeline', 'pubCrate', new rust.ExternalType(this.crate, 'azure_core::http', 'Pipeline')));
+        rustClient.fields.push(new rust.StructField('pipeline', 'pubCrate', new rust.ExternalType(this.crate, 'Pipeline', 'azure_core::http')));
         // anything other than public means non-instantiable client
         if (client.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
             const clientOptionsStruct = new rust.Struct(`${rustClient.name}Options`, 'pub');
-            const clientOptionsField = new rust.StructField('client_options', 'pub', new rust.ExternalType(this.crate, 'azure_core::http', 'ClientOptions'));
+            const clientOptionsField = new rust.StructField('client_options', 'pub', new rust.ExternalType(this.crate, 'ClientOptions', 'azure_core::http'));
+            clientOptionsField.docs.summary = 'Allows customization of the client.';
             clientOptionsField.defaultValue = 'ClientOptions::default()';
             clientOptionsStruct.fields.push(clientOptionsField);
             rustClient.constructable = new rust.ClientConstruction(new rust.ClientOptions(clientOptionsStruct));
-            clientOptionsStruct.docs.summary = `Options used when creating a [\`${rustClient.name}\`](${rustClient.name})`;
+            clientOptionsStruct.docs.summary = `Options used when creating a ${this.asDocLink(rustClient.name, rustClient.name)}`;
             // NOTE: per tcgc convention, if there is no param of kind credential
             // it means that the client doesn't require any kind of authentication.
             // HOWEVER, if there *is* a credential param, then the client *does not*
@@ -674,14 +693,23 @@ export class Adapter {
         else {
             throw new Error(`uninstantiable client ${client.name} has no parent`);
         }
+        for (const child of values(client.children)) {
+            const subClient = this.recursiveAdaptClient(child, rustClient);
+            this.adaptClientAccessor(client, child, rustClient, subClient);
+        }
         for (const method of client.methods) {
-            if (method.kind === 'clientaccessor') {
-                const subClient = this.recursiveAdaptClient(method.response, rustClient);
-                this.adaptClientAccessor(client, method, rustClient, subClient);
-            }
-            else {
-                this.adaptMethod(method, rustClient);
+            if (method.kind === 'lro' || method.kind === 'lropaging') {
+                // skip LROs for now so that codegen is unblocked
+                // TODO: https://github.com/Azure/typespec-rust/issues/188
+                this.ctx.program.reportDiagnostic({
+                    code: 'LroNotSupported',
+                    severity: 'warning',
+                    message: `skip emitting LRO ${method.name}`,
+                    target: method.__raw ? method.__raw.node : NoTarget,
+                });
+                continue;
             }
+            this.adaptMethod(method, rustClient);
         }
         this.crate.clients.push(rustClient);
         return rustClient;
@@ -732,6 +760,7 @@ export class Adapter {
         if (param.optional || param.clientDefaultValue) {
             optional = true;
             const paramField = new rust.StructField(paramName, 'pub', paramType);
+            paramField.docs = this.adaptDocs(param.summary, param.doc);
             constructable.options.type.fields.push(paramField);
             if (param.clientDefaultValue) {
                 paramField.defaultValue = `String::from("${param.clientDefaultValue}")`;
@@ -757,15 +786,15 @@ export class Adapter {
      * @param rustClient the client to which the method belongs
      * @param subClient the sub-client type that the method returns
      */
-    adaptClientAccessor(client, method, rustClient, subClient) {
+    adaptClientAccessor(parentClient, childClient, rustClient, subClient) {
         const clientAccessor = new rust.ClientAccessor(`get_${snakeCaseName(subClient.name)}`, rustClient, subClient);
         clientAccessor.docs.summary = `Returns a new instance of ${subClient.name}.`;
-        for (const param of method.parameters) {
+        for (const param of childClient.clientInitialization.parameters) {
             // check if the client's initializer already has this parameter.
             // if it does then omit it from the method sig as we'll populate
             // the child client's value from the parent.
             let existsOnParent = false;
-            for (const clientParam of client.clientInitialization.parameters) {
+            for (const clientParam of parentClient.clientInitialization.parameters) {
                 if (clientParam.name === param.name) {
                     existsOnParent = true;
                     break;
@@ -807,8 +836,8 @@ export class Adapter {
         const optionsLifetime = new rust.Lifetime('a');
         const methodOptionsStruct = new rust.Struct(`${rustClient.name}${codegen.pascalCase(srcMethodName)}Options`, 'pub');
         methodOptionsStruct.lifetime = optionsLifetime;
-        methodOptionsStruct.docs.summary = `Options to be passed to [\`${rustClient.name}::${methodName}()\`](crate::generated::clients::${rustClient.name}::${methodName}())`;
-        const clientMethodOptions = new rust.ExternalType(this.crate, 'azure_core::http', 'ClientMethodOptions');
+        methodOptionsStruct.docs.summary = `Options to be passed to ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
+        const clientMethodOptions = new rust.ExternalType(this.crate, 'ClientMethodOptions', 'azure_core::http');
         clientMethodOptions.lifetime = optionsLifetime;
         const methodOptionsField = new rust.StructField('method_options', 'pub', clientMethodOptions);
         methodOptionsField.docs.summary = 'Allows customization of the method call.';
@@ -834,18 +863,6 @@ export class Adapter {
                 break;
             case 'paging':
                 rustMethod = new rust.PageableMethod(methodName, rustClient, pub, methodOptions, httpMethod, httpPath);
-                if (method.nextLinkOperation) {
-                    // TODO: https://github.com/Azure/autorest.rust/issues/103
-                    throw new Error('next page operation NYI');
-                }
-                else if (method.nextLinkPath) {
-                    // this is the name of the field in the response type that contains the next link URL
-                    if (method.nextLinkPath.indexOf('.') > 0) {
-                        // TODO: https://github.com/Azure/autorest.rust/issues/102
-                        throw new Error('nested next link path NYI');
-                    }
-                    rustMethod.strategy = new rust.PageableStrategyNextLink(naming.getEscapedReservedName(snakeCaseName(method.nextLinkPath), 'prop'));
-                }
                 break;
             default:
                 throw new Error(`method kind ${method.kind} NYI`);
@@ -899,6 +916,13 @@ export class Adapter {
                     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);
@@ -931,10 +955,10 @@ export class Adapter {
             return this.adaptBodyFormat(defaultContentType);
         };
         // add any response headers
-        const addedHeaders = new Set();
+        const responseHeaders = new Array();
         for (const httpResp of method.operation.responses) {
             for (const header of httpResp.headers) {
-                if (addedHeaders.has(header.serializedName)) {
+                if (responseHeaders.find((e) => e.serializedName === header.serializedName)) {
                     continue;
                 }
                 else if (header.type.kind === 'constant') {
@@ -947,19 +971,7 @@ export class Adapter {
                     // response headers if they need it.
                     continue;
                 }
-                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(header.name, header.serializedName);
-                }
-                else {
-                    responseHeader = new rust.ResponseHeaderScalar(fixETagName(header.name), fixETagName(header.serializedName), this.getType(header.type));
-                }
-                responseHeader.docs = this.adaptDocs(header.summary, header.doc);
-                rustMethod.responseHeaders.push(responseHeader);
-                addedHeaders.add(header.serializedName);
+                responseHeaders.push(header);
             }
         }
         let returnType;
@@ -978,16 +990,16 @@ export class Adapter {
             if (!this.crate.models.includes(synthesizedModel)) {
                 this.crate.models.push(synthesizedModel);
             }
-            returnType = new rust.Pager(this.crate, synthesizedModel, format);
+            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')) {
-            returnType = new rust.Response(this.crate, new rust.Payload(this.getType(method.response.type), getBodyFormat()));
+            returnType = new rust.Response(this.crate, new rust.Payload(this.typeToWireType(this.getType(method.response.type)), getBodyFormat()));
         }
-        else if (rustMethod.responseHeaders.length > 0) {
+        else if (responseHeaders.length > 0) {
             // for methods that don't return a modeled type but return headers,
             // we need to return a marker type
             const markerType = new rust.MarkerType(`${rustClient.name}${codegen.pascalCase(method.name)}Result`);
-            markerType.docs.summary = `Contains results for [\`${rustClient.name}::${methodName}()\`](crate::generated::clients::${rustClient.name}::${methodName}())`;
+            markerType.docs.summary = `Contains results for ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
             returnType = new rust.Response(this.crate, markerType);
             this.crate.models.push(markerType);
         }
@@ -999,6 +1011,125 @@ 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);
+        if (method.kind === 'paging') {
+            // can't do this until the method has been completely adapted
+            rustMethod.strategy = this.adaptPageableMethodStrategy(method);
+        }
+    }
+    /**
+     * adapts response headers into a Rust ResponseHeadersTrait
+     * if there are no response headers, undefined is returned.
+     *
+     * @param client the client that contains the method
+     * @param method the method for which to create the trait
+     * @param responseHeaders the response headers array (can be empty)
+     * @returns a ResponseHeadersTrait or undefined
+     */
+    adaptResponseHeadersTrait(client, method, responseHeaders) {
+        if (responseHeaders.length === 0) {
+            return undefined;
+        }
+        // response header traits are only ever for marker types and payloads
+        let implFor;
+        switch (method.returns.type.kind) {
+            case 'pager':
+                implFor = method.returns.type.type;
+                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}`);
+                }
+                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}`);
+        }
+        let traitName;
+        switch (implFor.kind) {
+            case 'marker':
+                traitName = implFor.name;
+                break;
+            case 'payload':
+                traitName = this.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);
+        }
+        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
+     * @returns the pageable strategy
+     */
+    adaptPageableMethodStrategy(method) {
+        if (method.pagingMetadata.nextLinkOperation) {
+            // TODO: https://github.com/Azure/autorest.rust/issues/103
+            throw new Error('next page operation NYI');
+        }
+        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');
+            }
+            // 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}`);
+            }
+            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}`);
+            }
+            return new rust.PageableStrategyNextLink(nextLinkField);
+        }
+        else if (method.pagingMetadata.continuationTokenParameterSegments && method.pagingMetadata.continuationTokenResponseSegments) {
+            throw new Error('PageableStrategyContinuationToken NYI');
+        }
+        else {
+            throw new Error(`unhandled paging strategy for operation ${method.name}`);
+        }
     }
     /**
      * converts a tcgc operation parameter into a Rust method parameter
@@ -1042,7 +1173,7 @@ export class Adapter {
                     requestType = new rust.Bytes(this.crate);
                 }
                 else {
-                    requestType = new rust.Payload(paramType, this.adaptBodyFormat(param.defaultContentType));
+                    requestType = new rust.Payload(this.typeToWireType(paramType), this.adaptBodyFormat(param.defaultContentType));
                 }
                 adaptedParam = new rust.BodyParameter(paramName, paramLoc, param.optional, new rust.RequestContent(this.crate, requestType));
                 break;
@@ -1108,6 +1239,35 @@ export class Adapter {
         }
         return adaptedParam;
     }
+    /**
+     * narrows a rust.Type to a rust.WireType.
+     * if type isn't a rust.WireType, an error is thrown.
+     *
+     * @param type the type to narrow
+     * @returns the narrowed type
+     */
+    typeToWireType(type) {
+        switch (type.kind) {
+            case 'bytes':
+            case 'encodedBytes':
+            case 'enum':
+            case 'enumValue':
+            case 'Etag':
+            case 'hashmap':
+            case 'jsonValue':
+            case 'literal':
+            case 'model':
+            case 'offsetDateTime':
+            case 'scalar':
+            case 'str':
+            case 'String':
+            case 'Url':
+            case 'Vec':
+                return type;
+            default:
+                throw new Error(`cannot convert ${type.kind} to a wire type`);
+        }
+    }
     /**
      * converts a tcgc spread parameter into a Rust partial body parameter.
      *