Fix inline enum query/path params to use typed enums instead of String (#779)

* Fix git items recursionLevel parameter to use VersionControlRecursionType enum

The recursionLevel query parameter on git::items::get and git::items::list
was typed as impl Into<String>. It now uses models::VersionControlRecursionType,
a proper enum with variants None, OneLevel, OneLevelPlusNestedEmptyFolders, Full.

Changes:
- Patcher: add VersionControlRecursionType definition to git.json and replace
  the inline string enum on both the paths and x-ms-paths items operations
- Codegen: generate Display impl for all enum types so they can be serialised
  as URL query parameter values
- Examples: update git_items_list and git_repo_download_zip to use the new type

Closes #78

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Refactor: detect inline enum params in codegen instead of patching specs

Previously, the patcher was adding spec patches for each inline enum
query parameter (e.g. recursionLevel). This replaces that approach with
a proper code generator fix.

Changes:
- spec.rs: WebParameter::type_name() now returns TypeName::Reference(name)
  for parameters with a non-empty `enum` field and an `x-ms-enum.name`,
  instead of TypeName::String.
- spec.rs: new Spec::inline_parameter_enum_schemas() collects synthetic
  Schema entries for all inline enum parameters across all operations so
  the models codegen can generate named enum types for them.
- codegen_models.rs: all_schemas() calls inline_parameter_enum_schemas()
  to include those synthetic schemas alongside definition-based schemas.
- patcher.rs: remove the now-unnecessary patch_git_items_recursion_level
  patch function.

This automatically fixes all 105 inline enum query/path parameters across
all API areas (build, git, release, wit, tfvc, wiki, etc.), generating
proper typed enum types instead of impl Into<String> for each.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Fix import ordering in git_repo_download_zip example

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Update CHANGELOG.md for inline enum parameter changes

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: johnbatty

CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- All generated enum types now implement `std::fmt::Display`.
+
+### Changed
+
+- **Breaking:** Query and path parameters that accept a fixed set of values are
+  now typed as enums instead of `impl Into<String>`. This affects 105 parameters
+  across all API areas. Examples:
+  - `git::items::list` / `git::items::get`: `recursion_level` now takes
+    `models::VersionControlRecursionType` (also applies to `tfvc` and `wiki`)
+  - `build::builds::list`: `status_filter` takes `models::BuildStatus`,
+    `result_filter` takes `models::BuildResult`, `reason_filter` takes
+    `models::BuildReason`, `query_order` takes `models::BuildQueryOrder`
+  - `release`: `status_filter` takes `models::ReleaseStatus`, `query_order`
+    takes `models::ReleaseQueryOrder`, `deployment_status` takes
+    `models::DeploymentStatus`
+  - `git::pull_requests::list`: `search_criteria_status` takes
+    `models::PullRequestStatus`
+  - `wit::work_items::get_work_item`: `expand` takes `models::WorkItemExpand`
+
+  The enum types are defined in each module's `models` and carry the same
+  variant names as the API documentation (e.g. `VersionControlRecursionType::Full`,
+  `BuildStatus::InProgress`).
+
 ## [0.36.0]
 
 ### Added

autorust/codegen/src/codegen_models.rs

@@ -391,6 +391,17 @@ fn all_schemas(spec: &Spec) -> Result<IndexMap<RefKey, SchemaGen>> {
         }
     }
 
+    // synthetic schemas for inline enum query parameters (e.g. `type: string` + `enum` + `x-ms-enum`)
+    for (ref_key, schema) in spec.inline_parameter_enum_schemas()? {
+        if !all_schemas.contains_key(&ref_key) {
+            let doc_file = ref_key.file_path.clone();
+            all_schemas.insert(
+                ref_key.clone(),
+                SchemaGen::new(Some(ref_key), schema, doc_file),
+            );
+        }
+    }
+
     Ok(all_schemas)
 }
 
@@ -926,6 +937,29 @@ fn create_enum(
         quote! {}
     };
 
+    let mut display_arms = TokenStream::new();
+    for enum_value in &enum_values {
+        let value = &enum_value.value;
+        let variant_nm = value.to_camel_case_ident()?;
+        display_arms.extend(quote! {
+            Self::#variant_nm => write!(f, #value),
+        });
+    }
+    if property.is_model_as_string_enum() {
+        display_arms.extend(quote! {
+            Self::UnknownValue(s) => write!(f, "{}", s),
+        });
+    }
+    let display_code = quote! {
+        impl std::fmt::Display for #nm {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    #display_arms
+                }
+            }
+        }
+    };
+
     let doc_comment = DocCommentCode::from(&property.schema.common.description);
 
     let code = quote! {
@@ -937,6 +971,7 @@ fn create_enum(
         }
         #custom_serde_code
         #default_code
+        #display_code
     };
     let type_name = TypeNameCode::from(vec![namespace, Some(id)]);
 

autorust/codegen/src/spec.rs

@@ -322,6 +322,61 @@ impl Spec {
         Ok(resolved)
     }
 
+    /// Collect synthetic schemas for inline enum parameters across all operations.
+    ///
+    /// Parameters with `type: string`, a non-empty `enum` field, and an `x-ms-enum`
+    /// extension carry enough information to generate a proper named Rust enum type.
+    /// This method extracts those and returns them as schemas so the models codegen
+    /// can emit a top-level enum definition for each one.
+    pub fn inline_parameter_enum_schemas(&self) -> Result<Vec<(RefKey, Schema)>> {
+        let mut result: Vec<(RefKey, Schema)> = Vec::new();
+        let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
+        for (doc_file, doc) in self.docs() {
+            if !self.is_input_file(doc_file) {
+                continue;
+            }
+            let paths = self.resolve_path_map(doc_file, &doc.paths())?;
+            for (_path, item) in &paths {
+                let all_params: Vec<&autorust_openapi::Parameter> = item
+                    .parameters
+                    .iter()
+                    .filter_map(|p| match p {
+                        ReferenceOr::Item(p) => Some(p),
+                        _ => None,
+                    })
+                    .chain(item.operations().flat_map(|op| {
+                        op.parameters.iter().filter_map(|p| match p {
+                            ReferenceOr::Item(p) => Some(p),
+                            _ => None,
+                        })
+                    }))
+                    .collect();
+                for param in all_params {
+                    if param.common.enum_.is_empty() {
+                        continue;
+                    }
+                    if let Some(x_ms_enum) = &param.common.x_ms_enum {
+                        let name = x_ms_enum.name.clone();
+                        if seen.insert(name.clone()) {
+                            let schema = Schema {
+                                common: param.common.clone(),
+                                ..Default::default()
+                            };
+                            result.push((
+                                RefKey {
+                                    file_path: doc_file.clone(),
+                                    name,
+                                },
+                                schema,
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+        Ok(result)
+    }
+
     // only operations from listed input files
     fn operations_unresolved(&self) -> Result<Vec<WebOperationUnresolved>> {
         let mut operations: Vec<WebOperationUnresolved> = Vec::new();
@@ -629,6 +684,13 @@ impl WebParameter {
     }
 
     pub fn type_name(&self) -> Result<TypeName> {
+        // Inline enum parameters with an x-ms-enum name are generated as a named
+        // enum type in models, referenced here by that name.
+        if !self.0.common.enum_.is_empty() {
+            if let Some(x_ms_enum) = &self.0.common.x_ms_enum {
+                return Ok(TypeName::Reference(x_ms_enum.name.clone()));
+            }
+        }
         Ok(if let Some(_data_type) = self.data_type() {
             get_type_name_for_schema(&self.0.common)?
         } else if let Some(schema) = &self.0.schema {

azure_devops_rust_api/examples/git_items_list.rs

@@ -5,6 +5,7 @@
 // Git items (files and folders) list example.
 use anyhow::Result;
 use azure_devops_rust_api::git;
+use azure_devops_rust_api::git::models::VersionControlRecursionType;
 use std::env;
 
 mod utils;
@@ -28,7 +29,7 @@ async fn main() -> Result<()> {
     let items = git_client
         .items_client()
         .list(organization, repository_name, project)
-        .recursion_level("Full")
+        .recursion_level(VersionControlRecursionType::Full)
         .await?
         .value;
 

azure_devops_rust_api/examples/git_repo_download_zip.rs

@@ -7,6 +7,7 @@ use anyhow::Result;
 use azure_devops_rust_api::git;
 use azure_devops_rust_api::git::models::git_item::GitObjectType;
 use azure_devops_rust_api::git::models::GitItem;
+use azure_devops_rust_api::git::models::VersionControlRecursionType;
 use std::env;
 use std::io::Write;
 
@@ -23,7 +24,7 @@ async fn all_repo_items(
     let items = git_client
         .items_client()
         .list(organization, repository_name, project)
-        .recursion_level("Full")
+        .recursion_level(VersionControlRecursionType::Full)
         .await?
         .value;
     Ok(items)

azure_devops_rust_api/examples/wit_work_item_get.rs

@@ -74,7 +74,7 @@ async fn main() -> Result<()> {
     let work_item = wit_client
         .work_items_client()
         .get_work_item(&organization, work_item_id, &project)
-        .expand("All")
+        .expand(wit::models::WorkItemExpand::All)
         .await?;
 
     println!("Work item [{work_item_id}]:\n{work_item:#?}");

azure_devops_rust_api/src/accounts/models.rs

@@ -125,6 +125,17 @@ pub mod account {
         #[serde(rename = "moved")]
         Moved,
     }
+    impl std::fmt::Display for AccountStatus {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Self::None => write!(f, "none"),
+                Self::Enabled => write!(f, "enabled"),
+                Self::Disabled => write!(f, "disabled"),
+                Self::Deleted => write!(f, "deleted"),
+                Self::Moved => write!(f, "moved"),
+            }
+        }
+    }
     #[doc = "Type of account: Personal, Organization"]
     #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
     pub enum AccountType {
@@ -133,6 +144,14 @@ pub mod account {
         #[serde(rename = "organization")]
         Organization,
     }
+    impl std::fmt::Display for AccountType {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Self::Personal => write!(f, "personal"),
+                Self::Organization => write!(f, "organization"),
+            }
+        }
+    }
 }
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
 pub struct AccountCreateInfoInternal {