defmodule Kayrock.OffsetCommit do
  @api :offset_commit
  @moduledoc "Kayrock-generated module for the Kafka `#{@api}` API
"
  _ = " THIS CODE IS GENERATED BY KAYROCK"

  (
    @vmin 0
    @vmax 8
  )

  defmodule V0.Request do
    @vsn 0
    @api :offset_commit
    @schema group_id: :string,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct group_id: nil, topics: [], correlation_id: nil, client_id: nil
    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      0
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V0.Response.t(), binary})
    def response_deserializer do
      &V0.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V0.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V0.Request) do
    def serialize(%V0.Request{} = struct) do
      try do
        V0.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V0.Request{}) do
      V0.Request.api_vsn()
    end

    def response_deserializer(%V0.Request{}) do
      V0.Request.response_deserializer()
    end
  end

  defmodule V1.Request do
    @vsn 1
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  commit_timestamp: :int64,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    commit_timestamp: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      1
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V1.Response.t(), binary})
    def response_deserializer do
      &V1.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              commit_timestamp: :int64,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V1.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:int64, Map.fetch!(v, :commit_timestamp)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V1.Request) do
    def serialize(%V1.Request{} = struct) do
      try do
        V1.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V1.Request{}) do
      V1.Request.api_vsn()
    end

    def response_deserializer(%V1.Request{}) do
      V1.Request.response_deserializer()
    end
  end

  defmodule V2.Request do
    @vsn 2
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            retention_time_ms: :int64,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              retention_time_ms: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            retention_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      2
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V2.Response.t(), binary})
    def response_deserializer do
      &V2.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        retention_time_ms: :int64,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V2.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          serialize(:int64, Map.fetch!(struct, :retention_time_ms)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V2.Request) do
    def serialize(%V2.Request{} = struct) do
      try do
        V2.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V2.Request{}) do
      V2.Request.api_vsn()
    end

    def response_deserializer(%V2.Request{}) do
      V2.Request.response_deserializer()
    end
  end

  defmodule V3.Request do
    @vsn 3
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            retention_time_ms: :int64,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              retention_time_ms: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            retention_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      3
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V3.Response.t(), binary})
    def response_deserializer do
      &V3.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        retention_time_ms: :int64,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V3.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          serialize(:int64, Map.fetch!(struct, :retention_time_ms)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V3.Request) do
    def serialize(%V3.Request{} = struct) do
      try do
        V3.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V3.Request{}) do
      V3.Request.api_vsn()
    end

    def response_deserializer(%V3.Request{}) do
      V3.Request.response_deserializer()
    end
  end

  defmodule V4.Request do
    @vsn 4
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            retention_time_ms: :int64,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              retention_time_ms: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            retention_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      4
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V4.Response.t(), binary})
    def response_deserializer do
      &V4.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        retention_time_ms: :int64,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V4.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          serialize(:int64, Map.fetch!(struct, :retention_time_ms)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V4.Request) do
    def serialize(%V4.Request{} = struct) do
      try do
        V4.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V4.Request{}) do
      V4.Request.api_vsn()
    end

    def response_deserializer(%V4.Request{}) do
      V4.Request.response_deserializer()
    end
  end

  defmodule V5.Request do
    @vsn 5
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      5
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V5.Response.t(), binary})
    def response_deserializer do
      &V5.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V5.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V5.Request) do
    def serialize(%V5.Request{} = struct) do
      try do
        V5.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V5.Request{}) do
      V5.Request.api_vsn()
    end

    def response_deserializer(%V5.Request{}) do
      V5.Request.response_deserializer()
    end
  end

  defmodule V6.Request do
    @vsn 6
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_leader_epoch: :int32,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_leader_epoch: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      6
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V6.Response.t(), binary})
    def response_deserializer do
      &V6.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_leader_epoch: :int32,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V6.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:int32, Map.fetch!(v, :committed_leader_epoch)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V6.Request) do
    def serialize(%V6.Request{} = struct) do
      try do
        V6.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V6.Request{}) do
      V6.Request.api_vsn()
    end

    def response_deserializer(%V6.Request{}) do
      V6.Request.response_deserializer()
    end
  end

  defmodule V7.Request do
    @vsn 7
    @api :offset_commit
    @schema group_id: :string,
            generation_id: :int32,
            member_id: :string,
            group_instance_id: :nullable_string,
            topics:
              {:array,
               name: :string,
               partitions:
                 {:array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_leader_epoch: :int32,
                  committed_metadata: :nullable_string}}
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: nil,
              generation_id: nil,
              member_id: nil,
              group_instance_id: nil,
              topics: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            group_instance_id: nil | binary(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [
                  %{
                    partition_index: nil | integer(),
                    committed_offset: nil | integer(),
                    committed_leader_epoch: nil | integer(),
                    committed_metadata: nil | binary()
                  }
                ]
              }
            ],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      7
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V7.Response.t(), binary})
    def response_deserializer do
      &V7.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :string,
        generation_id: :int32,
        member_id: :string,
        group_instance_id: :nullable_string,
        topics:
          {:array,
           name: :string,
           partitions:
             {:array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_leader_epoch: :int32,
              committed_metadata: :nullable_string}}
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V7.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        [
          serialize(:string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:string, Map.fetch!(struct, :member_id)),
          serialize(:nullable_string, Map.fetch!(struct, :group_instance_id)),
          case Map.fetch!(struct, :topics) do
            nil ->
              <<-1::32-signed>>

            [] ->
              <<0::32-signed>>

            vals when is_list(vals) ->
              [
                <<length(vals)::32-signed>>,
                for v <- vals do
                  [
                    serialize(:string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        <<-1::32-signed>>

                      [] ->
                        <<0::32-signed>>

                      vals when is_list(vals) ->
                        [
                          <<length(vals)::32-signed>>,
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:int32, Map.fetch!(v, :committed_leader_epoch)),
                              serialize(:nullable_string, Map.fetch!(v, :committed_metadata))
                            ]
                          end
                        ]
                    end
                  ]
                end
              ]
          end
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V7.Request) do
    def serialize(%V7.Request{} = struct) do
      try do
        V7.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V7.Request{}) do
      V7.Request.api_vsn()
    end

    def response_deserializer(%V7.Request{}) do
      V7.Request.response_deserializer()
    end
  end

  defmodule V8.Request do
    @vsn 8
    @api :offset_commit
    @schema group_id: :compact_string,
            generation_id: :int32,
            member_id: :compact_string,
            group_instance_id: :compact_nullable_string,
            topics:
              {:compact_array,
               name: :compact_string,
               partitions:
                 {:compact_array,
                  partition_index: :int32,
                  committed_offset: :int64,
                  committed_leader_epoch: :int32,
                  committed_metadata: :compact_nullable_string,
                  tagged_fields: :tagged_fields},
               tagged_fields: :tagged_fields},
            tagged_fields: :tagged_fields
    @moduledoc "Kayrock-generated request struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"

    defstruct group_id: "",
              generation_id: nil,
              member_id: "",
              group_instance_id: nil,
              topics: [],
              tagged_fields: [],
              correlation_id: nil,
              client_id: nil

    import Elixir.Kayrock.Serialize
    @typedoc "Request struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            group_id: nil | binary(),
            generation_id: nil | integer(),
            member_id: nil | binary(),
            group_instance_id: nil | binary(),
            topics:
              nil
              | [
                  %{
                    name: nil | binary(),
                    partitions:
                      nil
                      | [
                          %{
                            partition_index: nil | integer(),
                            committed_offset: nil | integer(),
                            committed_leader_epoch: nil | integer(),
                            committed_metadata: nil | binary(),
                            tagged_fields: [{non_neg_integer(), binary()}]
                          }
                        ],
                    tagged_fields: [{non_neg_integer(), binary()}]
                  }
                ],
            tagged_fields: [{non_neg_integer(), binary()}],
            correlation_id: nil | integer(),
            client_id: nil | binary()
          }
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      8
    end

    @doc "Returns a function that can be used to deserialize the wire response from the\nbroker for this message type\n"
    @spec response_deserializer :: (binary -> {V8.Response.t(), binary})
    def response_deserializer do
      &V8.Response.deserialize/1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        group_id: :compact_string,
        generation_id: :int32,
        member_id: :compact_string,
        group_instance_id: :compact_nullable_string,
        topics:
          {:compact_array,
           name: :compact_string,
           partitions:
             {:compact_array,
              partition_index: :int32,
              committed_offset: :int64,
              committed_leader_epoch: :int32,
              committed_metadata: :compact_nullable_string,
              tagged_fields: :tagged_fields},
           tagged_fields: :tagged_fields},
        tagged_fields: :tagged_fields
      ]
    end

    @doc "Serialize a message to binary data for transfer to a Kafka broker"
    @spec serialize(t()) :: iodata
    def serialize(%V8.Request{} = struct) do
      [
        <<api_key()::16, api_vsn()::16, struct.correlation_id::32>>,
        case struct.client_id do
          nil -> <<-1::16-signed>>
          id -> <<byte_size(id)::16, id::binary>>
        end,
        <<0>>,
        [
          serialize(:compact_string, Map.fetch!(struct, :group_id)),
          serialize(:int32, Map.fetch!(struct, :generation_id)),
          serialize(:compact_string, Map.fetch!(struct, :member_id)),
          serialize(:compact_nullable_string, Map.fetch!(struct, :group_instance_id)),
          case Map.fetch!(struct, :topics) do
            nil ->
              Kayrock.Serialize.encode_unsigned_varint(0)

            [] ->
              Kayrock.Serialize.encode_unsigned_varint(1)

            vals when is_list(vals) ->
              [
                Kayrock.Serialize.encode_unsigned_varint(length(vals) + 1),
                for v <- vals do
                  [
                    serialize(:compact_string, Map.fetch!(v, :name)),
                    case Map.fetch!(v, :partitions) do
                      nil ->
                        Kayrock.Serialize.encode_unsigned_varint(0)

                      [] ->
                        Kayrock.Serialize.encode_unsigned_varint(1)

                      vals when is_list(vals) ->
                        [
                          Kayrock.Serialize.encode_unsigned_varint(length(vals) + 1),
                          for v <- vals do
                            [
                              serialize(:int32, Map.fetch!(v, :partition_index)),
                              serialize(:int64, Map.fetch!(v, :committed_offset)),
                              serialize(:int32, Map.fetch!(v, :committed_leader_epoch)),
                              serialize(
                                :compact_nullable_string,
                                Map.fetch!(v, :committed_metadata)
                              ),
                              serialize_tagged_fields(Map.get(v, :tagged_fields, []))
                            ]
                          end
                        ]
                    end,
                    serialize_tagged_fields(Map.get(v, :tagged_fields, []))
                  ]
                end
              ]
          end,
          serialize_tagged_fields(Map.get(struct, :tagged_fields, []))
        ]
      ]
    end
  end

  defimpl(Elixir.Kayrock.Request, for: V8.Request) do
    def serialize(%V8.Request{} = struct) do
      try do
        V8.Request.serialize(struct)
      rescue
        e -> reraise Kayrock.InvalidRequestError, {e, struct}, __STACKTRACE__
      end
    end

    def api_vsn(%V8.Request{}) do
      V8.Request.api_vsn()
    end

    def response_deserializer(%V8.Request{}) do
      V8.Request.response_deserializer()
    end
  end

  (
    @doc "Returns a request struct for this API with the given version"
    @spec get_request_struct(integer) :: request_t
  )

  def get_request_struct(0) do
    %V0.Request{}
  end

  def get_request_struct(1) do
    %V1.Request{}
  end

  def get_request_struct(2) do
    %V2.Request{}
  end

  def get_request_struct(3) do
    %V3.Request{}
  end

  def get_request_struct(4) do
    %V4.Request{}
  end

  def get_request_struct(5) do
    %V5.Request{}
  end

  def get_request_struct(6) do
    %V6.Request{}
  end

  def get_request_struct(7) do
    %V7.Request{}
  end

  def get_request_struct(8) do
    %V8.Request{}
  end

  defmodule V0.Response do
    @vsn 0
    @api :offset_commit
    @schema topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      0
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data
      deserialize_field(:root, :topics, %__MODULE__{correlation_id: correlation_id}, rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V1.Response do
    @vsn 1
    @api :offset_commit
    @schema topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      1
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data
      deserialize_field(:root, :topics, %__MODULE__{correlation_id: correlation_id}, rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V2.Response do
    @vsn 2
    @api :offset_commit
    @schema topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      2
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data
      deserialize_field(:root, :topics, %__MODULE__{correlation_id: correlation_id}, rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V3.Response do
    @vsn 3
    @api :offset_commit
    @schema throttle_time_ms: :int32,
            topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct throttle_time_ms: nil, topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            throttle_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      3
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        throttle_time_ms: :int32,
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data

      deserialize_field(
        :root,
        :throttle_time_ms,
        %__MODULE__{correlation_id: correlation_id},
        rest
      )
    end

    defp deserialize_field(:root, :throttle_time_ms, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:root, :topics, Map.put(acc, :throttle_time_ms, val), rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V4.Response do
    @vsn 4
    @api :offset_commit
    @schema throttle_time_ms: :int32,
            topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct throttle_time_ms: nil, topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            throttle_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      4
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        throttle_time_ms: :int32,
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data

      deserialize_field(
        :root,
        :throttle_time_ms,
        %__MODULE__{correlation_id: correlation_id},
        rest
      )
    end

    defp deserialize_field(:root, :throttle_time_ms, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:root, :topics, Map.put(acc, :throttle_time_ms, val), rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V5.Response do
    @vsn 5
    @api :offset_commit
    @schema throttle_time_ms: :int32,
            topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct throttle_time_ms: nil, topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            throttle_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      5
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        throttle_time_ms: :int32,
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data

      deserialize_field(
        :root,
        :throttle_time_ms,
        %__MODULE__{correlation_id: correlation_id},
        rest
      )
    end

    defp deserialize_field(:root, :throttle_time_ms, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:root, :topics, Map.put(acc, :throttle_time_ms, val), rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V6.Response do
    @vsn 6
    @api :offset_commit
    @schema throttle_time_ms: :int32,
            topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct throttle_time_ms: nil, topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            throttle_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      6
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        throttle_time_ms: :int32,
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data

      deserialize_field(
        :root,
        :throttle_time_ms,
        %__MODULE__{correlation_id: correlation_id},
        rest
      )
    end

    defp deserialize_field(:root, :throttle_time_ms, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:root, :topics, Map.put(acc, :throttle_time_ms, val), rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V7.Response do
    @vsn 7
    @api :offset_commit
    @schema throttle_time_ms: :int32,
            topics:
              {:array,
               name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct throttle_time_ms: nil, topics: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            throttle_time_ms: nil | integer(),
            topics: [
              %{
                name: nil | binary(),
                partitions: [%{partition_index: nil | integer(), error_code: nil | integer()}]
              }
            ],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      7
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        throttle_time_ms: :int32,
        topics:
          {:array,
           name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data

      deserialize_field(
        :root,
        :throttle_time_ms,
        %__MODULE__{correlation_id: correlation_id},
        rest
      )
    end

    defp deserialize_field(:root, :throttle_time_ms, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:root, :topics, Map.put(acc, :throttle_time_ms, val), rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, nil, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:topics, nil, Map.put(acc, :partitions, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      <<num_elements::32-signed, rest::binary>> = data

      {vals, rest} =
        if num_elements > 0 do
          Enum.reduce(1..num_elements, {[], rest}, fn _ix, {acc, d} ->
            {val, r} = deserialize_field(:topics, :name, %{}, d)
            {[val | acc], r}
          end)
        else
          {[], rest}
        end

      deserialize_field(:root, nil, Map.put(acc, :topics, Enum.reverse(vals)), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  defmodule V8.Response do
    @vsn 8
    @api :offset_commit
    @schema throttle_time_ms: :int32,
            topics:
              {:compact_array,
               name: :compact_string,
               partitions:
                 {:compact_array,
                  partition_index: :int32, error_code: :int16, tagged_fields: :tagged_fields},
               tagged_fields: :tagged_fields},
            tagged_fields: :tagged_fields
    @moduledoc "Kayrock-generated response struct for Kafka `#{@api}` v#{@vsn} API
messages

The schema of this API is
```
#{inspect(@schema, pretty: true)}
```
"
    _ = " THIS CODE IS GENERATED BY KAYROCK"
    defstruct throttle_time_ms: nil, topics: [], tagged_fields: [], correlation_id: nil
    @typedoc "Response struct for the Kafka `#{@api}` API v#{@vsn}
"
    @type t :: %__MODULE__{
            throttle_time_ms: nil | integer(),
            topics:
              nil
              | [
                  %{
                    name: nil | binary(),
                    partitions:
                      nil
                      | [
                          %{
                            partition_index: nil | integer(),
                            error_code: nil | integer(),
                            tagged_fields: [{non_neg_integer(), binary()}]
                          }
                        ],
                    tagged_fields: [{non_neg_integer(), binary()}]
                  }
                ],
            tagged_fields: [{non_neg_integer(), binary()}],
            correlation_id: integer()
          }
    import Elixir.Kayrock.Deserialize
    @doc "Returns the Kafka API key for this API"
    @spec api_key :: integer
    def api_key do
      Kayrock.KafkaSchemaMetadata.api_key(:offset_commit)
    end

    @doc "Returns the API version (#{@vsn}) implemented by this module"
    @spec api_vsn :: integer
    def api_vsn do
      8
    end

    @doc "Returns the schema of this message\n\nSee [above](#).\n"
    @spec schema :: term
    def schema do
      [
        throttle_time_ms: :int32,
        topics:
          {:compact_array,
           name: :compact_string,
           partitions:
             {:compact_array,
              partition_index: :int32, error_code: :int16, tagged_fields: :tagged_fields},
           tagged_fields: :tagged_fields},
        tagged_fields: :tagged_fields
      ]
    end

    @doc "Deserialize data for this version of this API\n"
    @spec deserialize(binary) :: {t(), binary}
    def deserialize(data) do
      <<correlation_id::32-signed, rest::binary>> = data
      {_tagged_fields, rest} = deserialize_tagged_fields(rest)

      deserialize_field(
        :root,
        :throttle_time_ms,
        %__MODULE__{correlation_id: correlation_id},
        rest
      )
    end

    defp deserialize_field(:root, :throttle_time_ms, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:root, :topics, Map.put(acc, :throttle_time_ms, val), rest)
    end

    defp deserialize_field(:topics, :name, acc, data) do
      {val, rest} = deserialize(:compact_string, data)
      deserialize_field(:topics, :partitions, Map.put(acc, :name, val), rest)
    end

    defp deserialize_field(:partitions, :partition_index, acc, data) do
      {val, rest} = deserialize(:int32, data)
      deserialize_field(:partitions, :error_code, Map.put(acc, :partition_index, val), rest)
    end

    defp deserialize_field(:partitions, :error_code, acc, data) do
      {val, rest} = deserialize(:int16, data)
      deserialize_field(:partitions, :tagged_fields, Map.put(acc, :error_code, val), rest)
    end

    defp deserialize_field(:partitions, :tagged_fields, acc, data) do
      {val, rest} = Kayrock.Deserialize.deserialize_tagged_fields(data)
      deserialize_field(:partitions, nil, Map.put(acc, :tagged_fields, val), rest)
    end

    defp deserialize_field(:topics, :partitions, acc, data) do
      {len_plus_one, rest} = Kayrock.Deserialize.decode_unsigned_varint(data)

      {vals, rest} =
        case len_plus_one do
          0 ->
            {nil, rest}

          1 ->
            {[], rest}

          _ ->
            Enum.reduce(1..(len_plus_one - 1), {[], rest}, fn _ix, {acc_inner, d} ->
              {val, r} = deserialize_field(:partitions, :partition_index, %{}, d)
              {[val | acc_inner], r}
            end)
        end

      final_vals =
        if is_nil(vals) do
          nil
        else
          Enum.reverse(vals)
        end

      deserialize_field(:topics, :tagged_fields, Map.put(acc, :partitions, final_vals), rest)
    end

    defp deserialize_field(:topics, :tagged_fields, acc, data) do
      {val, rest} = Kayrock.Deserialize.deserialize_tagged_fields(data)
      deserialize_field(:topics, nil, Map.put(acc, :tagged_fields, val), rest)
    end

    defp deserialize_field(:root, :topics, acc, data) do
      {len_plus_one, rest} = Kayrock.Deserialize.decode_unsigned_varint(data)

      {vals, rest} =
        case len_plus_one do
          0 ->
            {nil, rest}

          1 ->
            {[], rest}

          _ ->
            Enum.reduce(1..(len_plus_one - 1), {[], rest}, fn _ix, {acc_inner, d} ->
              {val, r} = deserialize_field(:topics, :name, %{}, d)
              {[val | acc_inner], r}
            end)
        end

      final_vals =
        if is_nil(vals) do
          nil
        else
          Enum.reverse(vals)
        end

      deserialize_field(:root, :tagged_fields, Map.put(acc, :topics, final_vals), rest)
    end

    defp deserialize_field(:root, :tagged_fields, acc, data) do
      {val, rest} = Kayrock.Deserialize.deserialize_tagged_fields(data)
      deserialize_field(:root, nil, Map.put(acc, :tagged_fields, val), rest)
    end

    defp deserialize_field(_, nil, acc, rest) do
      {acc, rest}
    end
  end

  (
    @doc "Deserializes raw wire data for this API with the given version"
    @spec deserialize(integer, binary) :: {response_t, binary}
  )

  def deserialize(0, data) do
    V0.Response.deserialize(data)
  end

  def deserialize(1, data) do
    V1.Response.deserialize(data)
  end

  def deserialize(2, data) do
    V2.Response.deserialize(data)
  end

  def deserialize(3, data) do
    V3.Response.deserialize(data)
  end

  def deserialize(4, data) do
    V4.Response.deserialize(data)
  end

  def deserialize(5, data) do
    V5.Response.deserialize(data)
  end

  def deserialize(6, data) do
    V6.Response.deserialize(data)
  end

  def deserialize(7, data) do
    V7.Response.deserialize(data)
  end

  def deserialize(8, data) do
    V8.Response.deserialize(data)
  end

  (
    @typedoc "Union type for all request structs for this API"
    @type request_t ::
            Kayrock.OffsetCommit.V8.Request.t()
            | Kayrock.OffsetCommit.V7.Request.t()
            | Kayrock.OffsetCommit.V6.Request.t()
            | Kayrock.OffsetCommit.V5.Request.t()
            | Kayrock.OffsetCommit.V4.Request.t()
            | Kayrock.OffsetCommit.V3.Request.t()
            | Kayrock.OffsetCommit.V2.Request.t()
            | Kayrock.OffsetCommit.V1.Request.t()
            | Kayrock.OffsetCommit.V0.Request.t()
  )

  (
    @typedoc "Union type for all response structs for this API"
    @type response_t ::
            Kayrock.OffsetCommit.V8.Response.t()
            | Kayrock.OffsetCommit.V7.Response.t()
            | Kayrock.OffsetCommit.V6.Response.t()
            | Kayrock.OffsetCommit.V5.Response.t()
            | Kayrock.OffsetCommit.V4.Response.t()
            | Kayrock.OffsetCommit.V3.Response.t()
            | Kayrock.OffsetCommit.V2.Response.t()
            | Kayrock.OffsetCommit.V1.Response.t()
            | Kayrock.OffsetCommit.V0.Response.t()
  )

  (
    @doc "Returns the minimum version of this API supported by Kayrock (#{@vmin})"
    @spec min_vsn :: integer
    def min_vsn do
      0
    end
  )

  (
    @doc "Returns the maximum version of this API supported by Kayrock (#{@vmax})"
    @spec max_vsn :: integer
    def max_vsn do
      8
    end
  )
end