@azure-tools/typespec-rust 0.11.0 → 0.13.0

package/dist/src/codegen/models.js

@@ -2,6 +2,7 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
+import * as codegen from '@azure-tools/codegen';
 import * as helpers from './helpers.js';
 import { Use } from './use.js';
 import * as rust from '../codemodel/index.js';
@@ -18,9 +19,9 @@ export function emitModels(crate, context) {
         return {};
     }
     return {
-        public: emitModelsInternal(crate, context, true),
+        public: emitModelsInternal(crate, context, 'pub'),
         serde: emitModelsSerde(crate, context),
-        internal: emitModelsInternal(crate, context, false),
+        internal: emitModelsInternal(crate, context, 'pubCrate'),
         xmlHelpers: emitXMLListWrappers(),
     };
 }
@@ -29,18 +30,18 @@ export function emitModels(crate, context) {
  *
  * @param crate the crate for which to emit models
  * @param context the context for the provided crate
- * @param pub true if we want public models, false for internal models
+ * @param visibility the visibility of the models to emit
  * @returns the model content or empty
  */
-function emitModelsInternal(crate, context, pub) {
+function emitModelsInternal(crate, context, visibility) {
     // for the internal models we might need to use public model types
-    const use = new Use(pub ? 'models' : undefined);
+    const use = new Use(visibility === 'pub' ? 'models' : 'modelsOther');
     use.addTypes('serde', ['Deserialize', 'Serialize']);
-    use.addType('typespec_client_core::fmt', 'SafeDebug');
+    use.addType('azure_core::fmt', 'SafeDebug');
     const indent = new helpers.indentation();
     let body = '';
     for (const model of crate.models) {
-        if (pub && model.kind === 'marker') {
+        if (visibility === 'pub' && model.kind === 'marker') {
             body += helpers.formatDocComment(model.docs);
             // marker types don't have any fields
             // and don't participate in serde.
@@ -52,12 +53,12 @@ function emitModelsInternal(crate, context, pub) {
             // marker types are always public, so we skip them for the internal models file
             continue;
         }
-        if (model.internal === pub) {
+        if (model.visibility !== visibility) {
             continue;
         }
         const bodyFormat = context.getModelBodyFormat(model);
         body += helpers.formatDocComment(model.docs);
-        body += helpers.annotationDerive('Default', 'azure_core::Model');
+        body += helpers.annotationDerive('Default', 'azure_core::http::Model');
         if ((model.flags & rust.ModelFlags.Output) === rust.ModelFlags.Output && (model.flags & rust.ModelFlags.Input) === 0) {
             // output-only models get the non_exhaustive annotation
             body += helpers.AnnotationNonExhaustive;
@@ -69,7 +70,7 @@ function emitModelsInternal(crate, context, pub) {
             // json is the default if not specified so no need to handle it
             body += `#[typespec(format = "xml")]\n`;
         }
-        body += `pub struct ${model.name} {\n`;
+        body += `${helpers.emitVisibility(model.visibility)}struct ${model.name} {\n`;
         for (const field of model.fields) {
             use.addForType(field.type);
             body += helpers.formatDocComment(field.docs);
@@ -80,35 +81,16 @@ function emitModelsInternal(crate, context, pub) {
             }
             // NOTE: usage of serde annotations like this means that base64 encoded bytes and
             // XML wrapped lists are mutually exclusive. it's not a real scenario at present.
-            if (helpers.unwrapOption(field.type).kind === 'offsetDateTime') {
-                serdeParams.add('default');
-                let optionMod = '';
-                if (field.type.kind === 'option') {
-                    optionMod = '::option';
-                }
-                // TODO: https://github.com/Azure/typespec-rust/issues/221
-                // specifically need to handle nested arrays of time types that require conversion
-                serdeParams.add(`with = "azure_core::date::${helpers.unwrapOption(field.type).encoding}${optionMod}"`);
-            }
-            else if (helpers.unwrapOption(field.type).kind === 'encodedBytes') {
-                // TODO: https://github.com/Azure/typespec-rust/issues/221
-                // specifically need to handle nested arrays of base64 encoded bytes
-                let format = '';
-                if (helpers.unwrapOption(field.type).encoding === 'url') {
-                    format = '_url_safe';
-                }
-                serdeParams.add('default');
-                serdeParams.add(`deserialize_with = "base64::deserialize${format}"`);
-                serdeParams.add(`serialize_with = "base64::serialize${format}"`);
-                use.addType('azure_core', 'base64');
+            if (helpers.unwrapType(field.type).kind === 'encodedBytes' || helpers.unwrapType(field.type).kind === 'offsetDateTime') {
+                getSerDeHelper(field.type, serdeParams, use);
             }
-            else if (bodyFormat === 'xml' && helpers.unwrapOption(field.type).kind === 'vector' && field.xmlKind !== 'unwrappedList') {
+            else if (bodyFormat === 'xml' && helpers.unwrapOption(field.type).kind === 'Vec' && field.xmlKind !== 'unwrappedList') {
                 // this is a wrapped list so we need a helper type for serde
                 const xmlListWrapper = getXMLListWrapper(field);
                 serdeParams.add('default');
                 serdeParams.add(`deserialize_with = "${xmlListWrapper.name}::unwrap"`);
                 serdeParams.add(`serialize_with = "${xmlListWrapper.name}::wrap"`);
-                use.addType('crate', `generated::xml_helpers::${xmlListWrapper.name}`);
+                use.addType('super::xml_helpers', xmlListWrapper.name);
             }
             // TODO: omit skip_serializing_if if we need to send explicit JSON null
             // https://github.com/Azure/typespec-rust/issues/78
@@ -119,17 +101,17 @@ function emitModelsInternal(crate, context, pub) {
                 serdeParams.add('default');
                 serdeParams.add('skip_serializing_if = "HashMap::is_empty"');
             }
-            else if (field.type.kind === 'vector') {
+            else if (field.type.kind === 'Vec') {
                 serdeParams.add('default');
-                // NOTE: we want to send an empty array for XML payloads
-                if (bodyFormat !== 'xml') {
+                // NOTE: we want to send an empty wrapper element for wrapped arrays
+                if (bodyFormat !== 'xml' || field.xmlKind === 'unwrappedList') {
                     serdeParams.add('skip_serializing_if = "Vec::is_empty"');
                 }
             }
             if (serdeParams.size > 0) {
                 body += `${indent.get()}#[serde(${Array.from(serdeParams).sort().join(', ')})]\n`;
             }
-            body += `${indent.get()}${helpers.emitPub(field.pub)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n\n`;
+            body += `${indent.get()}${helpers.emitVisibility(field.visibility)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n\n`;
         }
         body += '}\n\n';
     }
@@ -139,9 +121,9 @@ function emitModelsInternal(crate, context, pub) {
     }
     // emit TryFrom as required for internal models only.
     // public models will have their helpers in a separate file.
-    if (!pub) {
+    if (visibility !== 'pub') {
         for (const model of crate.models) {
-            if (model.kind === 'marker' || !model.internal) {
+            if (model.kind === 'marker' || model.visibility === 'pub') {
                 continue;
             }
             body += context.getTryFromForRequestContent(model, use);
@@ -150,7 +132,10 @@ function emitModelsInternal(crate, context, pub) {
     let content = helpers.contentPreamble();
     content += use.text();
     content += body;
-    return content;
+    return {
+        name: visibility === 'pub' ? 'pub_models' : 'crate_models',
+        content: content,
+    };
 }
 /**
  * returns serde helpers for public models.
@@ -161,11 +146,11 @@ function emitModelsInternal(crate, context, pub) {
  * @returns the model serde helpers content or undefined
  */
 function emitModelsSerde(crate, context) {
-    const use = new Use();
+    const use = new Use('modelsOther');
     let body = '';
     // emit TryFrom as required
     for (const model of crate.models) {
-        if (model.kind === 'marker' || model.internal) {
+        if (model.kind === 'marker' || model.visibility !== 'pub') {
             // skip internal models as their serde helpers are in the same file
             continue;
         }
@@ -177,14 +162,23 @@ function emitModelsSerde(crate, context) {
         }
         body += forReq;
     }
-    if (body.length === 0) {
+    const serdeHelpers = emitSerDeHelpers();
+    if (body.length === 0 && !serdeHelpers) {
         // no helpers
         return undefined;
     }
     let content = helpers.contentPreamble();
-    content += use.text();
-    content += body;
-    return content;
+    if (body.length > 0) {
+        content += use.text();
+        content += body;
+    }
+    if (serdeHelpers) {
+        content += serdeHelpers;
+    }
+    return {
+        name: 'models_serde',
+        content: content,
+    };
 }
 /**
  * returns the value for the rename option in a serde derive macro
@@ -297,7 +291,7 @@ function emitXMLListWrappers() {
     const wrapperTypes = Array.from(xmlListWrappers.values());
     wrapperTypes.sort((a, b) => { return helpers.sortAscending(a.name, b.name); });
     const indent = new helpers.indentation();
-    const use = new Use();
+    const use = new Use('modelsOther');
     use.addTypes('serde', ['Deserialize', 'Deserializer', 'Serialize', 'Serializer']);
     let body = '';
     for (const wrapperType of wrapperTypes) {
@@ -307,7 +301,7 @@ function emitXMLListWrappers() {
         }
         use.addForType(wrapperType.fieldType);
         const fieldType = helpers.getTypeDeclaration(wrapperType.fieldType);
-        body += `pub struct ${wrapperType.name} {\n`;
+        body += `pub(crate) struct ${wrapperType.name} {\n`;
         body += `${indent.get()}#[serde(default)]\n`;
         body += `${indent.get()}${wrapperType.fieldName}: ${fieldType},\n`;
         body += '}\n\n';
@@ -330,6 +324,419 @@ function emitXMLListWrappers() {
     content += '#![allow(non_camel_case_types)]\n#![allow(non_snake_case)]\n\n';
     content += use.text();
     content += body;
+    return {
+        name: 'xml_helpers',
+        content: content,
+    };
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// serde builder infrastructure
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// used by getSerDeHelper and emitSerDeHelpers
+const serdeHelpers = new Map();
+/**
+ * defines serde helpers for encodedBytes and offsetDateTime types.
+ * any other type will cause this function to throw.
+ *
+ * @param type the encodedBytes/offsetDateTime type for which to build serde helpers
+ * @param serdeParams the params that will be passed to the serde annotation
+ * @param use the use statement builder currently in scope
+ */
+function getSerDeHelper(type, serdeParams, use) {
+    const unwrapped = helpers.unwrapType(type);
+    switch (unwrapped.kind) {
+        case 'encodedBytes':
+            break;
+        case 'offsetDateTime':
+            break;
+        default:
+            throw new Error(`getSerDeHelper unexpected kind ${type.kind}`);
+    }
+    /**
+     * for hash maps and vectors, we emit a module containing the necessary
+     * helper functions to be used in a serde "with = <module>" statement.
+     * the module names are a concatenation of the type names.
+     * e.g. vec_offset_date_time, hashmap_vec_encoded_bytes_std etc
+     */
+    const buildSerDeModName = function (type) {
+        let name = codegen.deconstruct(type.kind).join('_');
+        let unwrapped = type;
+        while (unwrapped.kind === 'hashmap' || unwrapped.kind === 'Vec') {
+            unwrapped = unwrapped.type;
+            name += '_' + codegen.deconstruct(unwrapped.kind).join('_');
+        }
+        switch (unwrapped.kind) {
+            case 'encodedBytes':
+            case 'offsetDateTime':
+                name += `_${unwrapped.encoding}`;
+                break;
+            default:
+                throw new Error(`unexpected kind ${unwrapped.kind}`);
+        }
+        // we can reuse identical helpers across model types
+        if (!serdeHelpers.has(name)) {
+            serdeHelpers.set(name, type);
+        }
+        return name;
+    };
+    /** non-collection based impl */
+    const serdeEncodedBytes = function (encoding) {
+        const format = encoding === 'url' ? '_url_safe' : '';
+        serdeParams.add('default');
+        serdeParams.add(`deserialize_with = "base64::deserialize${format}"`);
+        serdeParams.add(`serialize_with = "base64::serialize${format}"`);
+        use.addType('azure_core', 'base64');
+    };
+    /** non-collection based impl */
+    const serdeOffsetDateTime = function (encoding, optional) {
+        serdeParams.add('default');
+        serdeParams.add(`with = "azure_core::date::${encoding}${optional ? '::option' : ''}"`);
+    };
+    switch (type.kind) {
+        case 'encodedBytes':
+            return serdeEncodedBytes(unwrapped.encoding);
+        case 'offsetDateTime':
+            // this is for spread params where the internal model's field isn't Option<T>
+            return serdeOffsetDateTime(unwrapped.encoding, false);
+        case 'hashmap':
+        case 'Vec':
+            use.addType('super', 'models_serde');
+            serdeParams.add('default');
+            serdeParams.add(`with = "models_serde::${buildSerDeModName(type)}"`);
+            break;
+        case 'option':
+            switch (type.type.kind) {
+                case 'encodedBytes':
+                    // TODO: this case should go away
+                    return serdeEncodedBytes(unwrapped.encoding);
+                case 'offsetDateTime':
+                    return serdeOffsetDateTime(unwrapped.encoding, true);
+            }
+            break;
+    }
+}
+/**
+ * emits serde helper modules or returns undefined
+ * if no serde helpers are required.
+ *
+ * @returns the helper modules or undefined
+ */
+function emitSerDeHelpers() {
+    if (serdeHelpers.size === 0) {
+        return undefined;
+    }
+    let content = '';
+    const helperKeys = Array.from(serdeHelpers.keys()).sort();
+    for (const helperKey of helperKeys) {
+        const use = new Use('modelsOther');
+        const indent = new helpers.indentation();
+        let modContent = `pub mod ${helperKey} {\n`;
+        modContent += `${indent.get()}#![allow(clippy::type_complexity)]\n`;
+        const deserialize = buildDeserialize(indent, serdeHelpers.get(helperKey), use);
+        const serialize = buildSerialize(indent, serdeHelpers.get(helperKey), use);
+        modContent += use.text(indent);
+        modContent += `${deserialize}\n${serialize}`;
+        modContent += '}\n\n'; // end pub mod
+        content += modContent;
+    }
+    return content;
+}
+/**
+ * constructs a serde deserialize function
+ *
+ * @param indent the indentation helper currently in scope
+ * @param type the type for which to build the helper
+ * @param use the use statement builder currently in scope
+ * @returns the pub fn deserialize function definition
+ */
+function buildDeserialize(indent, type, use) {
+    use.addTypes('serde', ['Deserialize', 'Deserializer']);
+    use.addType('std', 'result::Result');
+    use.addForType(type);
+    let content = `${indent.get()}pub fn deserialize<'de, D>(deserializer: D) -> Result<${helpers.getTypeDeclaration(type)}, D::Error>\n`;
+    content += `${indent.get()}where D: Deserializer<'de>\n${indent.get()}{\n`;
+    content += `${indent.push().get()}let to_deserialize = <Option<${getSerDeTypeDeclaration(type, 'deserialize')}>>::deserialize(deserializer)?;\n`;
+    content += `${indent.get()}${helpers.buildMatch(indent, 'to_deserialize', [
+        {
+            pattern: 'Some(to_deserialize)',
+            body: (indent) => recursiveBuildDeserializeBody(indent, use, {
+                caller: 'start',
+                type: type,
+                srcVar: 'to_deserialize',
+            }),
+        },
+        {
+            pattern: 'None',
+            body: (indent) => `${indent.get()}Ok(<${getSerDeTypeDeclaration(type, 'result')}>::default())\n`,
+        }
+    ])}\n`;
+    content += `${indent.pop().get()}}\n`;
     return content;
 }
+/**
+ * constructs a serde serialize function
+ *
+ * @param indent the indentation helper currently in scope
+ * @param type the type for which to build the helper
+ * @param use the use statement builder currently in scope
+ * @returns the pub fn serialize function definition
+ */
+function buildSerialize(indent, type, use) {
+    use.addTypes('serde', ['Serialize', 'Serializer']);
+    use.addType('std', 'result::Result');
+    use.addForType(type);
+    // clippy wants the outer-most Vec<T> to be a [] instead
+    const getTypeDeclaration = function (type) {
+        if (type.kind === 'Vec') {
+            return `[${helpers.getTypeDeclaration(type.type)}]`;
+        }
+        return helpers.getTypeDeclaration(type);
+    };
+    let content = `${indent.get()}pub fn serialize<S>(to_serialize: &${getTypeDeclaration(type)}, serializer: S) -> Result<S::Ok, S::Error>\n`;
+    content += `${indent.get()}where S: Serializer\n${indent.get()}{\n`;
+    content += recursiveBuildSerializeBody(indent.push(), use, {
+        caller: 'start',
+        type: type,
+        srcVar: 'to_serialize',
+    });
+    content += `${indent.pop().get()}}\n`;
+    return content;
+}
+// used by recursiveBuildDeserializeBody and recursiveBuildSerializeBody
+// to determine recursion depth. used to uniquely name local variables.
+let depth = 0;
+/**
+ * recursive state machine to construct the body of the deserialize function.
+ *
+ * @param indent the indentation helper currently in scope
+ * @param use the use statement builder currently in scope
+ * @param ctx the current context of the state machine
+ * @returns the contents of the Some(to_deserialize) match arm
+ */
+function recursiveBuildDeserializeBody(indent, use, ctx) {
+    switch (ctx.caller) {
+        case 'start':
+            depth = 0;
+            break;
+        default:
+            depth += 1;
+            break;
+    }
+    // the name of the destination var to hold the
+    // current decoded state. the name includes the
+    // recursion depth so each var name is unique.
+    const destVar = `decoded${depth}`;
+    /**
+     * adds the var in val to the collection, or does nothing
+     * depending on the value of caller.
+     *
+     * when valAsDefault is true, the value in val is returned.
+     * else the empty string is returned.
+     */
+    const insertOrPush = function (val, valAsDefault) {
+        switch (ctx.caller) {
+            case 'hashmap':
+                return `${indent.get()}decoded${depth - 1}.insert(kv.0, ${val});\n`;
+            case 'vec':
+                return `${indent.get()}decoded${depth - 1}.push(${val});\n`;
+            default:
+                return valAsDefault ? val : '';
+        }
+    };
+    let content = '';
+    switch (ctx.type.kind) {
+        case 'encodedBytes': {
+            // terminal case (NEVER the start case)
+            use.addType('azure_core', 'base64');
+            const base64Decode = `base64::${ctx.type.encoding === 'std' ? 'decode' : 'decode_url_safe'}`;
+            content = `${base64Decode}(${ctx.srcVar}).map_err(serde::de::Error::custom)?`;
+            content = insertOrPush(content, true);
+            break;
+        }
+        case 'hashmap': {
+            content = `${indent.get()}let mut ${destVar} = <${getSerDeTypeDeclaration(ctx.type, 'result')}>::new();\n`;
+            content += `${indent.get()}for kv in ${ctx.srcVar} {\n`;
+            content += recursiveBuildDeserializeBody(indent.push(), use, {
+                caller: 'hashmap',
+                type: ctx.type.type,
+                srcVar: 'kv.1',
+            });
+            content += `${indent.pop().get()}}\n`; // end for
+            content += insertOrPush(destVar, false);
+            break;
+        }
+        case 'offsetDateTime': {
+            // terminal case (NEVER the start case)
+            if (ctx.type.encoding !== 'unix_time') {
+                use.addType('azure_core', 'date');
+            }
+            const dateParse = ctx.type.encoding === 'unix_time' ? 'OffsetDateTime::from_unix_timestamp' : `date::parse_${ctx.type.encoding}`;
+            content = `${dateParse}(${ctx.type.encoding !== 'unix_time' ? '&' : ''}${ctx.srcVar}).map_err(serde::de::Error::custom)?`;
+            content = insertOrPush(content, true);
+            break;
+        }
+        case 'Vec': {
+            content = `${indent.get()}let mut ${destVar} = <${getSerDeTypeDeclaration(ctx.type, 'result')}>::new();\n`;
+            content += `${indent.get()}for v in ${ctx.srcVar} {\n`;
+            content += recursiveBuildDeserializeBody(indent.push(), use, {
+                caller: 'vec',
+                type: ctx.type.type,
+                srcVar: 'v',
+            });
+            content += `${indent.pop().get()}}\n`; // end for
+            content += insertOrPush(destVar, false);
+            break;
+        }
+        default:
+            throw new Error(`unexpected kind ${ctx.type.kind}`);
+    }
+    if (depth > 0) {
+        depth -= 1;
+    }
+    else {
+        content += `${indent.get()}Ok(${destVar})\n`;
+    }
+    return content;
+}
+/**
+ * recursive state machine to construct the body of the serialize function.
+ *
+ * @param indent the indentation helper currently in scope
+ * @param use the use statement builder currently in scope
+ * @param ctx the current context of the state machine
+ * @returns the contents of the serialize function
+ */
+function recursiveBuildSerializeBody(indent, use, ctx) {
+    switch (ctx.caller) {
+        case 'start':
+            depth = 0;
+            break;
+        default:
+            depth += 1;
+            break;
+    }
+    // the name of the destination var to hold the
+    // current encoded state. the name includes the
+    // recursion depth so each var name is unique.
+    const destVar = `encoded${depth}`;
+    /** inserts the var in val into the current HashMap<T, U> */
+    const hashMapInsert = function (val) {
+        return `${indent.get()}encoded${depth - 1}.insert(kv.0, ${val});\n`;
+    };
+    let content = '';
+    switch (ctx.type.kind) {
+        case 'encodedBytes': {
+            // terminal case (NEVER the start case)
+            use.addType('azure_core', 'base64');
+            const base64Encode = `base64::${ctx.type.encoding === 'std' ? 'encode' : 'encode_url_safe'}`;
+            switch (ctx.caller) {
+                case 'hashmap':
+                    content = `${hashMapInsert(`${base64Encode}(${ctx.srcVar})`)}`;
+                    break;
+                default:
+                    content = base64Encode;
+            }
+            break;
+        }
+        case 'hashmap': {
+            let enumerateMap = `${indent.get()}let mut ${destVar} = <${getSerDeTypeDeclaration(ctx.type, 'serialize')}>::new();\n`;
+            enumerateMap += `${indent.get()}for kv in ${ctx.srcVar} {\n`;
+            enumerateMap += recursiveBuildSerializeBody(indent.push(), use, {
+                caller: 'hashmap',
+                type: ctx.type.type,
+                srcVar: 'kv.1',
+            });
+            enumerateMap += `${indent.pop().get()}}\n`; // end for
+            switch (ctx.caller) {
+                case 'hashmap':
+                    content = enumerateMap;
+                    content += `${hashMapInsert(destVar)}`;
+                    break;
+                case 'start':
+                    content = enumerateMap;
+                    break;
+                case 'vec':
+                    content = `|${ctx.srcVar}|{\n`;
+                    content += enumerateMap;
+                    content += `${indent.get()}encoded${depth}}`;
+                    break;
+            }
+            break;
+        }
+        case 'offsetDateTime': {
+            // terminal case (NEVER the start case)
+            if (ctx.type.encoding !== 'unix_time') {
+                use.addType('azure_core', 'date');
+            }
+            content = ctx.type.encoding === 'unix_time' ? `${ctx.srcVar}.unix_timestamp()` : `date::to_${ctx.type.encoding}`;
+            switch (ctx.caller) {
+                case 'hashmap':
+                    content = `${hashMapInsert(`${content}${ctx.type.encoding !== 'unix_time' ? `(${ctx.srcVar})` : ''}`)}`;
+                    break;
+                case 'vec':
+                    if (ctx.type.encoding === 'unix_time') {
+                        content = `|v|${content}`;
+                    }
+                    break;
+            }
+            break;
+        }
+        case 'Vec': {
+            const convertVec = `.iter().map(${recursiveBuildSerializeBody(indent.push(), use, {
+                caller: 'vec',
+                type: ctx.type.type,
+                srcVar: 'v',
+            })}).collect()`;
+            indent.pop();
+            switch (ctx.caller) {
+                case 'hashmap':
+                    content = `${hashMapInsert(`${ctx.srcVar}${convertVec}`)}`;
+                    break;
+                case 'start':
+                    content = `${indent.get()}let ${destVar} = ${ctx.srcVar}${convertVec};\n`;
+                    break;
+                case 'vec':
+                    content = `|${ctx.srcVar}|${ctx.srcVar}${convertVec}`;
+                    break;
+            }
+            break;
+        }
+        default:
+            throw new Error(`unexpected kind ${ctx.type.kind}`);
+    }
+    if (depth > 0) {
+        depth -= 1;
+    }
+    else {
+        content += `${indent.get()}<${getSerDeTypeDeclaration(ctx.type, 'serialize')}>::serialize(&${destVar}, serializer)\n`;
+    }
+    return content;
+}
+/**
+ * a specialization of helpers.getTypeDeclaration for constructing
+ * the target type declarations in the serde helpers.
+ * the type declarations are slightly different depending on the usage
+ * context and the underlying generic type.
+ *
+ * @param type is the Rust type for which to emit the declaration
+ * @param usage defines the context in which the type is being used.
+ *              serialize - type is used in the serialize function
+ *            deserialize - type is used in the deserialize function
+ *                 result - type is used as the result type in the deserialize function
+ * @returns
+ */
+function getSerDeTypeDeclaration(type, usage) {
+    switch (type.kind) {
+        case 'encodedBytes':
+            return usage === 'result' ? 'Vec<u8>' : 'String';
+        case 'offsetDateTime':
+            return usage === 'result' ? 'OffsetDateTime' : type.encoding === 'unix_time' ? 'i64' : 'String';
+        case 'hashmap':
+            return `${type.name}<${usage === 'serialize' ? '&' : ''}String, ${getSerDeTypeDeclaration(type.type, usage)}>`;
+        case 'Vec':
+            return `${type.kind}<${getSerDeTypeDeclaration(type.type, usage)}>`;
+        default:
+            throw new Error(`unexpected kind ${type.kind}`);
+    }
+}
 //# sourceMappingURL=models.js.map