From b19ca1d4d571cd9079496ea3a2a5752fe6cbdce9 Mon Sep 17 00:00:00 2001
From: Artem Goncharov <artem.goncharov@gmail.com>
Date: Fri, 4 Apr 2025 13:54:41 +0200
Subject: [PATCH] Start building response types in the SDK

Introduce openstack_types crate with certain types that might be
helpful.

In the current form those cannot be reused from cli or tui since it is
necessary to tweak StructableTable to be able to treat different
rendering of cli and tui versus the raw structs.

Change-Id: I23674e0e9119f75739139e015f44d1100d6d84e2
---
 codegenerator/cli.py                          |  19 +-
 codegenerator/common/__init__.py              |   7 +
 codegenerator/common/rust.py                  | 205 +++++++-
 codegenerator/rust_cli.py                     |  14 +-
 codegenerator/rust_sdk.py                     |   2 +-
 codegenerator/rust_tui.py                     |   8 +-
 codegenerator/rust_types.py                   | 462 ++++++++++++++++++
 codegenerator/templates/rust_types/impl.rs.j2 |  99 ++++
 codegenerator/templates/rust_types/mod.rs.j2  |  30 ++
 zuul.d/rust.yaml                              |  20 +-
 10 files changed, 830 insertions(+), 36 deletions(-)
 create mode 100644 codegenerator/rust_types.py
 create mode 100644 codegenerator/templates/rust_types/impl.rs.j2
 create mode 100644 codegenerator/templates/rust_types/mod.rs.j2

diff --git a/codegenerator/cli.py b/codegenerator/cli.py
index e97df91..18fc799 100644
--- a/codegenerator/cli.py
+++ b/codegenerator/cli.py
@@ -33,6 +33,7 @@ from codegenerator.openapi_spec import OpenApiSchemaGenerator
 # from codegenerator.osc import OSCGenerator
 from codegenerator.rust_cli import RustCliGenerator
 from codegenerator.rust_tui import RustTuiGenerator
+from codegenerator.rust_types import RustTypesGenerator
 from codegenerator.rust_sdk import RustSdkGenerator
 from codegenerator.types import Metadata
 
@@ -159,6 +160,7 @@ def main():
             "rust-sdk",
             "rust-cli",
             "rust-tui",
+            "rust-types",
             "openapi-spec",
             "jsonschema",
             "metadata",
@@ -201,6 +203,7 @@ def main():
         "rust-cli": RustCliGenerator(),
         "rust-tui": RustTuiGenerator(),
         "rust-sdk": RustSdkGenerator(),
+        "rust-types": RustTypesGenerator(),
         "openapi-spec": OpenApiSchemaGenerator(),
         "jsonschema": JsonSchemaGenerator(),
         "metadata": MetadataGenerator(),
@@ -226,8 +229,13 @@ def main():
                 continue
             for op, op_data in res_data.operations.items():
                 logging.debug(f"Processing operation {op_data.operation_id}")
-                if args.target in op_data.targets:
-                    op_args = op_data.targets[args.target]
+                metadata_target = (
+                    "rust-sdk"
+                    if args.target in ["rust-sdk", "rust-types"]
+                    else args.target
+                )
+                if metadata_target in op_data.targets:
+                    op_args = op_data.targets[metadata_target]
                     if not op_args.service_type:
                         op_args.service_type = res.split(".")[0]
                     if not op_args.api_version:
@@ -254,7 +262,7 @@ def main():
                     ):
                         res_mods.append((mod_path, mod_name, path, class_name))
             rust_sdk_extensions = res_data.extensions.get("rust-sdk")
-            if rust_sdk_extensions:
+            if rust_sdk_extensions and args.target != "rust-types":
                 additional_modules = rust_sdk_extensions.setdefault(
                     "additional_modules", []
                 )
@@ -273,7 +281,10 @@ def main():
                         )
                     )
 
-        if args.target in ["rust-sdk", "rust-tui"] and not args.resource:
+        if (
+            args.target in ["rust-sdk", "rust-tui", "rust-types"]
+            and not args.resource
+        ):
             resource_results: dict[str, dict] = {}
             for mod_path, mod_name, path, class_name in res_mods:
                 mn = "/".join(mod_path)
diff --git a/codegenerator/common/__init__.py b/codegenerator/common/__init__.py
index 8c3c629..9544071 100644
--- a/codegenerator/common/__init__.py
+++ b/codegenerator/common/__init__.py
@@ -562,6 +562,13 @@ def get_rust_sdk_mod_path(service_type: str, api_version: str, path: str):
     return mod_path
 
 
+def get_rust_types_mod_path(service_type: str, api_version: str, path: str):
+    """Construct mod path for rust types crate"""
+    mod_path = [service_type.replace("-", "_"), api_version]
+    mod_path.extend([x.lower() for x in get_resource_names_from_url(path)])
+    return mod_path
+
+
 def get_rust_cli_mod_path(service_type: str, api_version: str, path: str):
     """Construct mod path for rust sdk"""
     mod_path = [service_type.replace("-", "_"), api_version]
diff --git a/codegenerator/common/rust.py b/codegenerator/common/rust.py
index 0e393ec..4e50516 100644
--- a/codegenerator/common/rust.py
+++ b/codegenerator/common/rust.py
@@ -26,6 +26,19 @@ from codegenerator import common
 CODEBLOCK_RE = re.compile(r"```(\w*)$")
 
 
+BASIC_FIELDS = [
+    "id",
+    "name",
+    "title",
+    "created_at",
+    "updated_at",
+    "uuid",
+    "state",
+    "status",
+    "operating_status",
+]
+
+
 class Boolean(BasePrimitiveType):
     """Basic Boolean"""
 
@@ -264,6 +277,20 @@ class Dictionary(BaseCombinedType):
     base_type: str = "dict"
     value_type: BasePrimitiveType | BaseCombinedType | BaseCompoundType
 
+    @property
+    def imports(self):
+        imports: set[str] = {"std::collections::HashMap"}
+        imports.update(self.value_type.imports)
+        return imports
+
+    @property
+    def type_hint(self):
+        return f"HashMap<String, {self.value_type.type_hint}>"
+
+    @property
+    def lifetimes(self):
+        return set()
+
 
 class StructField(BaseModel):
     local_name: str
@@ -338,6 +365,101 @@ class Struct(BaseCompoundType):
         return set()
 
 
+class StructFieldResponse(StructField):
+    """Response Structure Field"""
+
+    @property
+    def type_hint(self):
+        typ_hint = self.data_type.type_hint
+        if self.is_optional and not typ_hint.startswith("Option<"):
+            typ_hint = f"Option<{typ_hint}>"
+        return typ_hint
+
+    @property
+    def serde_macros(self):
+        macros = set()
+        if self.local_name != self.remote_name:
+            macros.add(f'rename="{self.remote_name}"')
+        if len(macros) > 0:
+            return f"#[serde({', '.join(sorted(macros))})]"
+        return ""
+
+    def get_structable_macros(
+        self,
+        struct: "StructResponse",
+        service_name: str,
+        resource_name: str,
+        operation_type: str,
+    ):
+        macros = set()
+        if self.is_optional or self.data_type.type_hint.startswith("Option<"):
+            macros.add("optional")
+        if self.local_name != self.remote_name:
+            macros.add(f'title="{self.remote_name}"')
+        # Fully Qualified Attribute Name
+        fqan: str = ".".join(
+            [service_name, resource_name, self.remote_name]
+        ).lower()
+        # Check the known alias of the field by FQAN
+        alias = common.FQAN_ALIAS_MAP.get(fqan)
+        if operation_type in ["list", "list_from_struct"]:
+            if (
+                "id" in struct.fields.keys()
+                and not (
+                    self.local_name in BASIC_FIELDS or alias in BASIC_FIELDS
+                )
+            ) or (
+                "id" not in struct.fields.keys()
+                and (self.local_name not in list(struct.fields.keys())[-10:])
+                and not (
+                    self.local_name in BASIC_FIELDS or alias in BASIC_FIELDS
+                )
+            ):
+                # Only add "wide" flag if field is not in the basic fields AND
+                # there is at least "id" field existing in the struct OR the
+                # field is not in the first 10
+                macros.add("wide")
+            if (
+                self.local_name == "state"
+                and "status" not in struct.fields.keys()
+            ):
+                macros.add("status")
+            elif (
+                self.local_name == "operating_status"
+                and "status" not in struct.fields.keys()
+            ):
+                macros.add("status")
+        if self.data_type.type_hint in [
+            "Value",
+            "Option<Value>",
+            "Vec<Value>",
+            "Option<Vec<Value>>",
+        ]:
+            macros.add("pretty")
+        return f"#[structable({', '.join(sorted(macros))})]"
+
+
+class StructResponse(Struct):
+    field_type_class_: Type[StructField] = StructFieldResponse
+
+    @property
+    def imports(self):
+        imports: set[str] = {"serde::Deserialize", "serde::Serialize"}
+        for field in self.fields.values():
+            imports.update(field.data_type.imports)
+        # In difference to the SDK and Input we do not currently handle
+        # additional_fields of the struct in response
+        # if self.additional_fields_type:
+        #     imports.add("std::collections::BTreeMap")
+        #     imports.update(self.additional_fields_type.imports)
+        return imports
+
+    @property
+    def static_lifetime(self):
+        """Return Rust `<'lc>` lifetimes representation"""
+        return f"<{', '.join(self.lifetimes)}>" if self.lifetimes else ""
+
+
 class EnumKind(BaseModel):
     name: str
     description: str | None = None
@@ -346,7 +468,11 @@ class EnumKind(BaseModel):
     @property
     def type_hint(self):
         if isinstance(self.data_type, Struct):
-            return self.data_type.name + self.data_type.static_lifetime
+            print(f"Getting type hint of {self.data_type}")
+            try:
+                return self.data_type.name + self.data_type.static_lifetime
+            except Exception as ex:
+                print(f"Error {ex}")
         return self.data_type.type_hint
 
     @property
@@ -361,6 +487,14 @@ class Enum(BaseCompoundType):
     original_data_type: BaseCompoundType | BaseCompoundType | None = None
     _kind_type_class = EnumKind
 
+    @property
+    def derive_container_macros(self) -> str:
+        return "#[derive(Debug, Deserialize, Clone, Serialize)]"
+
+    @property
+    def serde_container_macros(self) -> str:
+        return "#[serde(untagged)]"
+
     @property
     def type_hint(self):
         return self.name + (
@@ -394,14 +528,18 @@ class StringEnum(BaseCompoundType):
     variants: dict[str, set[str]] = {}
     imports: set[str] = {"serde::Deserialize", "serde::Serialize"}
     lifetimes: set[str] = set()
-    derive_container_macros: str = (
-        "#[derive(Debug, Deserialize, Clone, Serialize)]"
-    )
     builder_container_macros: str | None = None
-    serde_container_macros: str | None = None  # "#[serde(untagged)]"
     serde_macros: set[str] | None = None
     original_data_type: BaseCompoundType | BaseCompoundType | None = None
 
+    @property
+    def derive_container_macros(self) -> str:
+        return "#[derive(Debug, Deserialize, Clone, Serialize)]"
+
+    @property
+    def serde_container_macros(self) -> str:
+        return "#[serde(untagged)]"
+
     @property
     def type_hint(self):
         """Get type hint"""
@@ -435,6 +573,36 @@ class StringEnum(BaseCompoundType):
         return "#[serde(" + ", ".join(sorted(macros)) + ")]"
 
 
+class HashMapResponse(Dictionary):
+    """Wrapper around a simple dictionary to implement Display trait"""
+
+    lifetimes: set[str] = set()
+
+    @property
+    def type_hint(self):
+        return f"HashMapString{self.value_type.type_hint.replace('<', '').replace('>', '')}"
+
+    @property
+    def imports(self):
+        imports = self.value_type.imports
+        imports.add("std::collections::HashMap")
+        return imports
+
+
+class TupleStruct(Struct):
+    """Rust tuple struct without named fields"""
+
+    base_type: str = "struct"
+    tuple_fields: list[StructField] = []
+
+    @property
+    def imports(self):
+        imports: set[str] = set()
+        for field in self.tuple_fields:
+            imports.update(field.data_type.imports)
+        return imports
+
+
 class RequestParameter(BaseModel):
     """OpenAPI request parameter in the Rust SDK form"""
 
@@ -521,6 +689,8 @@ class TypeManager:
     #: List of the models to be ignored
     ignored_models: list[model.Reference] = []
 
+    root_name: str | None = "Body"
+
     def __init__(self):
         self.models = []
         self.refs = {}
@@ -672,7 +842,9 @@ class TypeManager:
             )
 
         if not model_ref:
-            model_ref = model.Reference(name="Body", type=typ.__class__)
+            model_ref = model.Reference(
+                name=self.root_name, type=typ.__class__
+            )
         self.refs[model_ref] = typ
         return typ
 
@@ -901,8 +1073,14 @@ class TypeManager:
             name = getattr(model_data_type, "name", None)
             if (
                 name
-                and name in unique_models
-                and unique_models[name].hash_ != model_.reference.hash_
+                and model_.reference
+                and (
+                    (
+                        name in unique_models
+                        and unique_models[name].hash_ != model_.reference.hash_
+                    )
+                    or name == self.root_name
+                )
             ):
                 # There is already a model with this name.
                 if model_.reference and model_.reference.parent:
@@ -975,6 +1153,7 @@ class TypeManager:
             elif (
                 name
                 and name in unique_models
+                and model_.reference
                 and unique_models[name].hash_ == model_.reference.hash_
                 # image.metadef.namespace have weird occurences of itself
                 and model_.reference != unique_models[name]
@@ -993,12 +1172,12 @@ class TypeManager:
             if (
                 k
                 and isinstance(v, (Enum, Struct, StringEnum))
-                and k.name != "Body"
+                and k.name != self.root_name
             ):
                 yield v
             elif (
                 k
-                and k.name != "Body"
+                and k.name != self.root_name
                 and isinstance(v, self.option_type_class)
             ):
                 if isinstance(v.item_type, Enum):
@@ -1007,7 +1186,7 @@ class TypeManager:
     def get_root_data_type(self):
         """Get TLA type"""
         for k, v in self.refs.items():
-            if not k or (k.name == "Body" and isinstance(v, Struct)):
+            if not k or (k.name == self.root_name and isinstance(v, Struct)):
                 if isinstance(v.fields, dict):
                     # There might be tuple Struct (with
                     # fields as list)
@@ -1022,7 +1201,9 @@ class TypeManager:
                         )
                         v.fields[field_names[0]].is_optional = False
                 return v
-            elif not k or (k.name == "Body" and isinstance(v, Dictionary)):
+            elif not k or (
+                k.name == self.root_name and isinstance(v, Dictionary)
+            ):
                 # Response is a free style Dictionary
                 return v
         # No root has been found, make a dummy one
diff --git a/codegenerator/rust_cli.py b/codegenerator/rust_cli.py
index 467e067..40316f1 100644
--- a/codegenerator/rust_cli.py
+++ b/codegenerator/rust_cli.py
@@ -645,7 +645,7 @@ class RequestTypeManager(common_rust.TypeManager):
                     )
                     if not model_ref:
                         model_ref = model.Reference(
-                            name="Body", type=typ.__class__
+                            name=self.root_name, type=typ.__class__
                         )
                     if type_model.value_type.reference:
                         self.ignored_models.append(
@@ -999,7 +999,7 @@ class ResponseTypeManager(common_rust.TypeManager):
                         common_rust.Array,
                     ),
                 )
-                and k.name != "Body"
+                and k.name != self.root_name
             ):
                 key = v.base_type + v.type_hint
                 if key not in emited_data:
@@ -1023,7 +1023,7 @@ class RustCliGenerator(BaseGenerator):
         :param *args: Path to the code to format
         """
         for path in args:
-            subprocess.run(["rustfmt", "--edition", "2021", path])
+            subprocess.run(["rustfmt", "--edition", "2024", path])
 
     def get_parser(self, parser):
         parser.add_argument(
@@ -1284,7 +1284,8 @@ class RustCliGenerator(BaseGenerator):
                                 )
                                 response_type_manager.refs[
                                     model.Reference(
-                                        name="Body", type=HashMapResponse
+                                        name=response_type_manager.root_name,
+                                        type=HashMapResponse,
                                     )
                                 ] = root_dict
 
@@ -1329,7 +1330,10 @@ class RustCliGenerator(BaseGenerator):
                             tuple_struct = TupleStruct(name="Response")
                             tuple_struct.tuple_fields.append(field)
                             response_type_manager.refs[
-                                model.Reference(name="Body", type=TupleStruct)
+                                model.Reference(
+                                    name=response_type_manager.root_name,
+                                    type=TupleStruct,
+                                )
                             ] = tuple_struct
                         elif (
                             response_def["type"] == "array"
diff --git a/codegenerator/rust_sdk.py b/codegenerator/rust_sdk.py
index e147f95..b74d522 100644
--- a/codegenerator/rust_sdk.py
+++ b/codegenerator/rust_sdk.py
@@ -345,7 +345,7 @@ class RustSdkGenerator(BaseGenerator):
         :param *args: Path to the code to format
         """
         for path in args:
-            subprocess.run(["rustfmt", "--edition", "2021", path])
+            subprocess.run(["rustfmt", "--edition", "2024", path])
 
     def get_parser(self, parser):
         parser.add_argument(
diff --git a/codegenerator/rust_tui.py b/codegenerator/rust_tui.py
index edb08fb..91336dc 100644
--- a/codegenerator/rust_tui.py
+++ b/codegenerator/rust_tui.py
@@ -336,7 +336,7 @@ class TypeManager(common_rust.TypeManager):
         """Get all subtypes excluding TLA"""
         for k, v in self.refs.items():
             if self.sdk_type_manager:
-                if k.name == "Body":
+                if k.name == self.root_name:
                     sdk_type = self.sdk_type_manager.get_root_data_type()
                 else:
                     sdk_type = self.sdk_type_manager.refs[k]
@@ -347,12 +347,12 @@ class TypeManager(common_rust.TypeManager):
                 and isinstance(
                     v, (common_rust.Enum, Struct, common_rust.StringEnum)
                 )
-                and k.name != "Body"
+                and k.name != self.root_name
             ):
                 yield (v, sdk_type)
             elif (
                 k
-                and k.name != "Body"
+                and k.name != self.root_name
                 and isinstance(v, self.option_type_class)
             ):
                 if isinstance(v.item_type, common_rust.Enum):
@@ -485,7 +485,7 @@ class ResponseTypeManager(common_rust.TypeManager):
                         common_rust.Array,
                     ),
                 )
-                and k.name != "Body"
+                and k.name != self.root_name
             ):
                 key = v.base_type + v.type_hint
                 if key not in emited_data:
diff --git a/codegenerator/rust_types.py b/codegenerator/rust_types.py
new file mode 100644
index 0000000..8ee29e5
--- /dev/null
+++ b/codegenerator/rust_types.py
@@ -0,0 +1,462 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+import logging
+from pathlib import Path
+import re
+import subprocess
+from typing import Type, Any
+
+from codegenerator.base import BaseGenerator
+from codegenerator.common import BasePrimitiveType
+from codegenerator.common import BaseCombinedType
+from codegenerator.common import BaseCompoundType
+from codegenerator import common
+from codegenerator import model
+from codegenerator.common import BaseCompoundType
+from codegenerator.common import rust as common_rust
+
+
+class IntString(common.BasePrimitiveType):
+    """CLI Integer or String"""
+
+    imports: set[str] = {"crate::common::IntString"}
+    type_hint: str = "IntString"
+    clap_macros: set[str] = set()
+
+
+class NumString(common.BasePrimitiveType):
+    """CLI Number or String"""
+
+    imports: set[str] = {"crate::common::NumString"}
+    type_hint: str = "NumString"
+    clap_macros: set[str] = set()
+
+
+class BoolString(common.BasePrimitiveType):
+    """CLI Boolean or String"""
+
+    imports: set[str] = {"crate::common::BoolString"}
+    type_hint: str = "BoolString"
+    clap_macros: set[str] = set()
+
+
+class ResponseTypeManager(common_rust.TypeManager):
+    primitive_type_mapping = {}
+    data_type_mapping = {model.Struct: common_rust.StructResponse}
+
+    def get_model_name(self, model_ref: model.Reference | None) -> str:
+        """Get the localized model type name
+
+        In order to avoid collision between structures in request and
+        response we prefix all types with `Response`
+        :returns str: Type name
+        """
+        if not model_ref:
+            return self.root_name or "Response"
+        return "".join(
+            x.capitalize()
+            for x in re.split(common.SPLIT_NAME_RE, model_ref.name)
+        )
+
+    def _simplify_oneof_combinations(self, type_model, kinds):
+        """Simplify certain known oneOf combinations"""
+        kinds_classes = [x["class"] for x in kinds]
+        if (
+            common_rust.String in kinds_classes
+            and common_rust.Number in kinds_classes
+        ):
+            # oneOf [string, number] => NumString
+            kinds.clear()
+            kinds.append({"local": NumString(), "class": NumString})
+        elif (
+            common_rust.String in kinds_classes
+            and common_rust.Integer in kinds_classes
+        ):
+            # oneOf [string, integer] => NumString
+            kinds.clear()
+            kinds.append({"local": IntString(), "class": IntString})
+        elif (
+            common_rust.String in kinds_classes
+            and common_rust.Boolean in kinds_classes
+        ):
+            # oneOf [string, boolean] => String
+            kinds.clear()
+            kinds.append({"local": BoolString(), "class": BoolString})
+        super()._simplify_oneof_combinations(type_model, kinds)
+
+    def _get_struct_type(self, type_model: model.Struct) -> common_rust.Struct:
+        """Convert model.Struct into Rust `Struct`"""
+        struct_class = self.data_type_mapping[model.Struct]
+        mod = struct_class(
+            name=self.get_model_name(type_model.reference),
+            description=common_rust.sanitize_rust_docstrings(
+                type_model.description
+            ),
+        )
+        field_class = mod.field_type_class_
+        for field_name, field in type_model.fields.items():
+            is_nullable: bool = False
+            field_data_type = self.convert_model(field.data_type)
+            if isinstance(field_data_type, self.option_type_class):
+                # Unwrap Option into "is_nullable" NOTE: but perhaps
+                # Option<Option> is better (not set vs set explicitly to None
+                # )
+                is_nullable = True
+                if isinstance(field_data_type.item_type, common_rust.Array):
+                    # Unwrap Option<Option<Vec...>>
+                    field_data_type = field_data_type.item_type
+            # elif isinstance(field_data_type, struct_class):
+            #     field_data_type = JsonValue(**field_data_type.model_dump())
+            #     self.ignored_models.append(field.data_type)
+            f = field_class(
+                local_name=self.get_local_attribute_name(field_name),
+                remote_name=self.get_remote_attribute_name(field_name),
+                description=common_rust.sanitize_rust_docstrings(
+                    field.description
+                ),
+                data_type=field_data_type,
+                is_optional=not field.is_required,
+                is_nullable=is_nullable,
+            )
+            mod.fields[field_name] = f
+        if type_model.additional_fields:
+            definition = type_model.additional_fields
+            # Structure allows additional fields
+            if isinstance(definition, bool):
+                mod.additional_fields_type = self.primitive_type_mapping[
+                    model.PrimitiveAny
+                ]
+            else:
+                mod.additional_fields_type = self.convert_model(definition)
+        return mod
+
+    def get_subtypes(self):
+        """Get all subtypes excluding TLA"""
+        emited_data: set[str] = set()
+        for k, v in self.refs.items():
+            if (
+                k
+                and isinstance(
+                    v,
+                    (
+                        common_rust.Enum,
+                        common_rust.Struct,
+                        common_rust.StringEnum,
+                        common_rust.Dictionary,
+                        common_rust.Array,
+                    ),
+                )
+                and k.name != self.root_name
+            ):
+                key = v.base_type + v.type_hint
+                if key not in emited_data:
+                    emited_data.add(key)
+                    yield v
+
+    def get_imports(self):
+        """Get complete set of additional imports required by all models in scope"""
+        imports: set[str] = super().get_imports()
+        imports.discard("serde::Deserialize")
+        imports.discard("serde::Serialize")
+        return imports
+
+
+class RustTypesGenerator(BaseGenerator):
+    def __init__(self):
+        super().__init__()
+
+    def _format_code(self, *args):
+        """Format code using Rustfmt
+
+        :param *args: Path to the code to format
+        """
+        for path in args:
+            subprocess.run(["rustfmt", path])
+
+    def get_parser(self, parser):
+        # parser.add_argument(
+        #    "--response-key",
+        #    help="Rust types response key (only required when normal detection does not work)",
+        # )
+
+        return parser
+
+    def _render_command(
+        self, context: dict, impl_template: str, impl_dest: Path
+    ):
+        """Render command code"""
+        self._render(impl_template, context, impl_dest.parent, impl_dest.name)
+
+    def generate(
+        self, res, target_dir, openapi_spec=None, operation_id=None, args=None
+    ):
+        """Generate code for the Rust openstack_types"""
+        logging.debug(
+            "Generating Rust Types code for %s in %s [%s]",
+            operation_id,
+            target_dir,
+            args,
+        )
+
+        if not openapi_spec:
+            openapi_spec = common.get_openapi_spec(args.openapi_yaml_spec)
+        if not operation_id:
+            operation_id = args.openapi_operation_id
+        (path, method, spec) = common.find_openapi_operation(
+            openapi_spec, operation_id
+        )
+        if args.operation_type == "find" or method == "HEAD":
+            return
+
+        # srv_name, resource_name = res.split(".") if res else (None, None)
+        path_resources = common.get_resource_names_from_url(path)
+        resource_name = common.get_resource_names_from_url(path)[-1]
+
+        mime_type = None
+        openapi_parser = model.OpenAPISchemaParser()
+        # Collect all operation parameters
+
+        # Process body information
+        # List of operation variants (based on the body)
+        operation_variants = common.get_operation_variants(
+            spec, args.operation_name
+        )
+
+        api_ver_matches: re.Match | None = None
+        path_elements = path.lstrip("/").split("/")
+        api_ver: dict[str, int] = {}
+        ver_prefix: str | None = None
+        if path_elements:
+            api_ver_matches = re.match(common.VERSION_RE, path_elements[0])
+            if api_ver_matches and api_ver_matches.groups():
+                # Remember the version prefix to discard it in the template
+                ver_prefix = path_elements[0]
+
+        for operation_variant in operation_variants:
+            logging.debug(f"Processing variant {operation_variant}")
+            response_type_manager: common_rust.TypeManager = (
+                ResponseTypeManager()
+            )
+            additional_imports = set()
+            result_is_list: bool = False
+            is_list_paginated: bool = False
+
+            if api_ver_matches:
+                api_ver = {
+                    "major": api_ver_matches.group(1),
+                    "minor": api_ver_matches.group(3) or 0,
+                }
+            else:
+                api_ver = {}
+
+            class_name = "".join(
+                x.capitalize()
+                for x in re.split(common.SPLIT_NAME_RE, resource_name)
+            )
+            response_type_manager.root_name = class_name + "Response"
+            operation_body = operation_variant.get("body")
+            mod_name = "_".join(
+                x.lower()
+                for x in re.split(
+                    common.SPLIT_NAME_RE,
+                    (
+                        args.module_name
+                        or args.operation_name
+                        or args.operation_type.value
+                        or method
+                    ),
+                )
+            )
+
+            mod_path = common.get_rust_types_mod_path(
+                args.service_type,
+                args.api_version,
+                args.alternative_module_path or path,
+            )
+            mod_path.append("response")
+
+            response_key: str | None = None
+            result_def: dict = {}
+            response_def: dict | None = {}
+            resource_header_metadata: dict = {}
+
+            # Get basic information about response
+            if method.upper() != "HEAD":
+                response = common.find_response_schema(
+                    spec["responses"],
+                    args.response_key or resource_name,
+                    (
+                        args.operation_name
+                        if args.operation_type == "action"
+                        else None
+                    ),
+                )
+                if response:
+                    if args.response_key:
+                        response_key = (
+                            args.response_key
+                            if args.response_key != "null"
+                            else None
+                        )
+                    else:
+                        response_key = resource_name
+                    response_def, _ = common.find_resource_schema(
+                        response, None, response_key
+                    )
+
+                    if response_def:
+                        if response_def.get("type", "object") == "object" or (
+                            # BS metadata is defined with type: ["object",
+                            # "null"]
+                            isinstance(response_def.get("type"), list)
+                            and "object" in response_def["type"]
+                        ):
+                            (root, response_types) = openapi_parser.parse(
+                                response_def
+                            )
+                            if isinstance(root, model.Dictionary):
+                                value_type: (
+                                    common_rust.BasePrimitiveType
+                                    | common_rust.BaseCombinedType
+                                    | common_rust.BaseCompoundType
+                                    | None
+                                ) = None
+                                try:
+                                    value_type = (
+                                        response_type_manager.convert_model(
+                                            root.value_type
+                                        )
+                                    )
+                                except Exception:
+                                    # In rare cases we can not conter
+                                    # value_type since it depends on different
+                                    # types. We are here in the output
+                                    # simplification, so just downcast it to
+                                    # JsonValue (what is anyway our goal)
+                                    value_type = common_rust.JsonValue()
+                                # if not isinstance(value_type, common_rust.BasePrimitiveType):
+                                #    value_type = JsonValue(original_data_type=value_type)
+                                root_dict = common_rust.HashMapResponse(
+                                    value_type=value_type
+                                )
+                                response_type_manager.refs[
+                                    model.Reference(
+                                        name=response_type_manager.root_name,
+                                        type=common_rust.HashMapResponse,
+                                    )
+                                ] = root_dict
+
+                            else:
+                                response_type_manager.set_models(
+                                    response_types
+                                )
+
+                        elif response_def["type"] == "string":
+                            (root_dt, _) = openapi_parser.parse(response_def)
+                            if not root_dt:
+                                raise RuntimeError(
+                                    "Response data can not be processed"
+                                )
+                            field = common_rust.StructField(
+                                local_name="dummy",
+                                remote_name="dummy",
+                                data_type=response_type_manager.convert_model(
+                                    root_dt
+                                ),
+                                is_optional=False,
+                            )
+                            tuple_struct = common_rust.TupleStruct(
+                                name=class_name
+                            )
+                            tuple_struct.tuple_fields.append(field)
+                            response_type_manager.refs[
+                                model.Reference(
+                                    name=response_type_manager.root_name,
+                                    type=common_rust.TupleStruct,
+                                )
+                            ] = tuple_struct
+                        elif (
+                            response_def["type"] == "array"
+                            and "items" in response_def
+                        ):
+                            (_, response_types) = openapi_parser.parse(
+                                response_def["items"]
+                            )
+                            response_type_manager.set_models(response_types)
+
+                        response_props = response.get("properties", {})
+                        if (
+                            response_props
+                            and response_props[
+                                list(response_props.keys())[0]
+                            ].get("type")
+                            == "array"
+                        ):
+                            result_is_list = True
+
+                else:
+                    return
+
+            additional_imports.update(response_type_manager.get_imports())
+
+            context = {
+                "operation_id": operation_id,
+                "operation_type": spec.get(
+                    "x-openstack-operation-type", args.operation_type
+                ),
+                "command_description": common_rust.sanitize_rust_docstrings(
+                    common.make_ascii_string(spec.get("description"))
+                ),
+                "class_name": class_name,
+                "sdk_service_name": common.get_rust_service_type_from_str(
+                    args.service_type
+                ),
+                "url": path.lstrip("/").lstrip(ver_prefix).lstrip("/"),
+                "method": method,
+                "response_type_manager": response_type_manager,
+                "api_ver": api_ver,
+                "target_class_name": class_name,
+                "resource_name": resource_name,
+                "additional_imports": additional_imports,
+            }
+
+            work_dir = Path(target_dir, "rust", "openstack_types", "src")
+            impl_path = Path(work_dir, "/".join(mod_path), f"{mod_name}.rs")
+            # Generate methods for the GET resource command
+            self._render_command(context, "rust_types/impl.rs.j2", impl_path)
+
+            self._format_code(impl_path)
+
+            yield (mod_path, mod_name, "response", class_name)
+
+    def generate_mod(
+        self, target_dir, mod_path, mod_list, url, resource_name, service_name
+    ):
+        """Generate collection module (include individual modules)"""
+        work_dir = Path(target_dir, "rust", "openstack_types", "src")
+        impl_path = Path(
+            work_dir, "/".join(mod_path[0:-1]), f"{mod_path[-1]}.rs"
+        )
+
+        context = {
+            "mod_list": mod_list,
+            "mod_path": mod_path,
+            "url": url,
+            "resource_name": resource_name,
+            "service_name": service_name,
+        }
+
+        # Generate methods for the GET resource command
+        self._render_command(context, "rust_types/mod.rs.j2", impl_path)
+
+        self._format_code(impl_path)
diff --git a/codegenerator/templates/rust_types/impl.rs.j2 b/codegenerator/templates/rust_types/impl.rs.j2
new file mode 100644
index 0000000..a513a7f
--- /dev/null
+++ b/codegenerator/templates/rust_types/impl.rs.j2
@@ -0,0 +1,99 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// WARNING: This file is automatically generated from OpenAPI schema using
+// `openstack-codegenerator`.
+{% import 'rust_macros.j2' as macros with context -%}
+//! Response type for the {{ method }} {{ url }} operation
+
+use serde::{Deserialize, Serialize};
+{% for mod in additional_imports | sort -%}
+use {{ mod }};
+{% endfor %}
+
+{% with data_type = response_type_manager.get_root_data_type() %}
+{%- if data_type.__class__.__name__ == "StructResponse" %}
+  {%- if data_type.fields %}
+    /// {{ target_class_name }} response representation
+    #[derive(Clone, Deserialize, Serialize)]
+    struct {{ data_type.name }} {
+      {%- for k, v in data_type.fields | dictsort %}
+        {% if not (operation_type == "list" and k in ["links"]) %}
+          {{ macros.docstring(v.description, indent=4) }}
+          {% if v.serde_macros -%}
+          {{ v.serde_macros }}
+          {% endif -%}
+          {{ v.local_name }}: {{ v.type_hint }},
+        {%- endif %}
+      {%- endfor %}
+
+    }
+  {%- else %}
+    {#- No response data at all #}
+  {%- endif %}
+
+{%- elif data_type.__class__.__name__ == "TupleStruct" %}
+    {#- tuple struct requires custom implementation of StructTable #}
+    /// {{ target_class_name }} response representation
+    #[derive(Deserialize, Serialize)]
+    #[derive(Clone)]
+    struct {{ class_name }}(
+      {%- for field in data_type.tuple_fields %}
+        {{ field.type_hint }},
+      {%- endfor %}
+    );
+
+{%- elif data_type.__class__.__name__ == "HashMapResponse" %}
+    /// Response data as HashMap type
+    #[derive(Deserialize, Serialize)]
+    struct {{ class_name }}(HashMap<String, {{ data_type.value_type.type_hint }}>);
+{%- endif %}
+{%- endwith %}
+
+{%- for subtype in response_type_manager.get_subtypes() %}
+  {%- if subtype["fields"] is defined %}
+    {{ macros.docstring(subtype.description, indent=0) }}
+    /// `{{ subtype.name }}` type
+    #[derive(Clone, Debug)]
+    #[derive(Deserialize, Serialize)]
+    {{ subtype.base_type }} {{ subtype.name }} {
+      {%- for k, v in subtype.fields | dictsort %}
+        {{ v.local_name }}: {{ v.type_hint }},
+      {%- endfor %}
+    }
+
+    {%- elif subtype.base_type == "enum" and subtype.__class__.__name__ == "StringEnum" %}
+    {{ macros.docstring(subtype.description, indent=0) }}
+    {{ subtype.derive_container_macros }}
+    {{ subtype.serde_container_macros }}
+    pub enum {{ subtype.name }} {
+      {% for kind in subtype.variants %}
+      // {{ kind or "Empty" }}
+      {{ subtype.variant_serde_macros(kind) }}
+      {{ kind or "Empty" }},
+      {% endfor %}
+    }
+
+    {%- elif subtype.base_type == "enum" %}
+    {{ macros.docstring(subtype.description, indent=0) }}
+    {{ subtype.derive_container_macros }}
+    {{ subtype.serde_container_macros }}
+    pub enum {{ subtype.name }} {
+      {% for kind, def in subtype.kinds.items() %}
+      // {{ kind }}
+      {{ kind }}({{ def.type_hint }}),
+      {%- endfor %}
+    }
+  {%- endif %}
+{%- endfor %}
diff --git a/codegenerator/templates/rust_types/mod.rs.j2 b/codegenerator/templates/rust_types/mod.rs.j2
new file mode 100644
index 0000000..cb80ed5
--- /dev/null
+++ b/codegenerator/templates/rust_types/mod.rs.j2
@@ -0,0 +1,30 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// WARNING: This file is automatically generated from OpenAPI schema using
+// `openstack-codegenerator`.
+{% if mod_path|length > 2 %}
+//! `{{ url }}` REST operations of {{ service_name }}
+{%- else %}
+//! `{{ service_name|capitalize }}` Service bindings
+{%- endif %}
+
+{%- for mod in mod_list|sort %}
+{%- if mod in ["trait", "type"] %}
+pub mod r#{{ mod }};
+{%- else %}
+pub mod {{ mod }};
+{%- endif %}
+{%- endfor %}
+
diff --git a/zuul.d/rust.yaml b/zuul.d/rust.yaml
index 520ba94..826da8e 100644
--- a/zuul.d/rust.yaml
+++ b/zuul.d/rust.yaml
@@ -14,34 +14,34 @@
       codegenerator_service_metadata_target_map:
         - service: "block-storage"
           metadata: "metadata/block-storage_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "compute"
           metadata: "metadata/compute_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "container-infrastructure-management"
           metadata: "metadata/container-infrastructure-management_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli"]
+          targets: ["rust-sdk", "rust-cli", "rust-types"]
         - service: "dns"
           metadata: "metadata/dns_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "identity"
           metadata: "metadata/identity_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "image"
           metadata: "metadata/image_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "load-balancer"
           metadata: "metadata/load-balancer_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "network"
           metadata: "metadata/network_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli", "rust-tui"]
+          targets: ["rust-sdk", "rust-cli", "rust-tui", "rust-types"]
         - service: "object-store"
           metadata: "metadata/object-store_metadata.yaml"
-          targets: ["rust-sdk"]
+          targets: ["rust-sdk", "rust-types"]
         - service: "placement"
           metadata: "metadata/placement_metadata.yaml"
-          targets: ["rust-sdk", "rust-cli"]
+          targets: ["rust-sdk", "rust-cli", "rust-types"]
         # - service: "shared-file-system"
         #   metadata: "metadata/shared-file-system_metadata.yaml"
         #   targets: ["rust-sdk"]