defmodule Kayrock.KafkaSchemaMetadata do
  @moduledoc false
  _ = "THIS CODE IS GENERATED BY KAYROCK"

  def all_apis do
    [
      :produce,
      :fetch,
      :list_offsets,
      :metadata,
      :offset_commit,
      :offset_fetch,
      :find_coordinator,
      :join_group,
      :heartbeat,
      :leave_group,
      :sync_group,
      :describe_groups,
      :list_groups,
      :sasl_handshake,
      :api_versions,
      :create_topics,
      :delete_topics,
      :delete_records,
      :init_producer_id,
      :offset_for_leader_epoch,
      :add_partitions_to_txn,
      :add_offsets_to_txn,
      :end_txn,
      :txn_offset_commit,
      :describe_acls,
      :create_acls,
      :delete_acls,
      :describe_configs,
      :alter_configs,
      :alter_replica_log_dirs,
      :describe_log_dirs,
      :sasl_authenticate,
      :create_partitions,
      :create_delegation_token,
      :renew_delegation_token,
      :expire_delegation_token,
      :describe_delegation_token,
      :delete_groups,
      :elect_leaders,
      :incremental_alter_configs,
      :alter_partition_reassignments,
      :list_partition_reassignments,
      :offset_delete
    ]
  end

  def version_range(:produce) do
    {0, 8}
  end

  def version_range(:fetch) do
    {0, 11}
  end

  def version_range(:list_offsets) do
    {0, 5}
  end

  def version_range(:metadata) do
    {0, 9}
  end

  def version_range(:offset_commit) do
    {0, 8}
  end

  def version_range(:offset_fetch) do
    {0, 6}
  end

  def version_range(:find_coordinator) do
    {0, 3}
  end

  def version_range(:join_group) do
    {0, 6}
  end

  def version_range(:heartbeat) do
    {0, 4}
  end

  def version_range(:leave_group) do
    {0, 4}
  end

  def version_range(:sync_group) do
    {0, 4}
  end

  def version_range(:describe_groups) do
    {0, 5}
  end

  def version_range(:list_groups) do
    {0, 3}
  end

  def version_range(:sasl_handshake) do
    {0, 1}
  end

  def version_range(:api_versions) do
    {0, 3}
  end

  def version_range(:create_topics) do
    {0, 5}
  end

  def version_range(:delete_topics) do
    {0, 4}
  end

  def version_range(:delete_records) do
    {0, 1}
  end

  def version_range(:init_producer_id) do
    {0, 2}
  end

  def version_range(:offset_for_leader_epoch) do
    {0, 3}
  end

  def version_range(:add_partitions_to_txn) do
    {0, 1}
  end

  def version_range(:add_offsets_to_txn) do
    {0, 1}
  end

  def version_range(:end_txn) do
    {0, 1}
  end

  def version_range(:txn_offset_commit) do
    {0, 2}
  end

  def version_range(:describe_acls) do
    {0, 1}
  end

  def version_range(:create_acls) do
    {0, 1}
  end

  def version_range(:delete_acls) do
    {0, 1}
  end

  def version_range(:describe_configs) do
    {0, 2}
  end

  def version_range(:alter_configs) do
    {0, 1}
  end

  def version_range(:alter_replica_log_dirs) do
    {0, 1}
  end

  def version_range(:describe_log_dirs) do
    {0, 1}
  end

  def version_range(:sasl_authenticate) do
    {0, 1}
  end

  def version_range(:create_partitions) do
    {0, 1}
  end

  def version_range(:create_delegation_token) do
    {0, 2}
  end

  def version_range(:renew_delegation_token) do
    {0, 1}
  end

  def version_range(:expire_delegation_token) do
    {0, 1}
  end

  def version_range(:describe_delegation_token) do
    {0, 1}
  end

  def version_range(:delete_groups) do
    {0, 2}
  end

  def version_range(:elect_leaders) do
    {0, 2}
  end

  def version_range(:incremental_alter_configs) do
    {0, 1}
  end

  def version_range(:alter_partition_reassignments) do
    {0, 0}
  end

  def version_range(:list_partition_reassignments) do
    {0, 0}
  end

  def version_range(:offset_delete) do
    {0, 0}
  end

  (
    def api_key(:produce) do
      0
    end

    def api_key(0) do
      :produce
    end
  )

  (
    def api_key(:fetch) do
      1
    end

    def api_key(1) do
      :fetch
    end
  )

  (
    def api_key(:list_offsets) do
      2
    end

    def api_key(2) do
      :list_offsets
    end
  )

  (
    def api_key(:metadata) do
      3
    end

    def api_key(3) do
      :metadata
    end
  )

  (
    def api_key(:offset_commit) do
      8
    end

    def api_key(8) do
      :offset_commit
    end
  )

  (
    def api_key(:offset_fetch) do
      9
    end

    def api_key(9) do
      :offset_fetch
    end
  )

  (
    def api_key(:find_coordinator) do
      10
    end

    def api_key(10) do
      :find_coordinator
    end
  )

  (
    def api_key(:join_group) do
      11
    end

    def api_key(11) do
      :join_group
    end
  )

  (
    def api_key(:heartbeat) do
      12
    end

    def api_key(12) do
      :heartbeat
    end
  )

  (
    def api_key(:leave_group) do
      13
    end

    def api_key(13) do
      :leave_group
    end
  )

  (
    def api_key(:sync_group) do
      14
    end

    def api_key(14) do
      :sync_group
    end
  )

  (
    def api_key(:describe_groups) do
      15
    end

    def api_key(15) do
      :describe_groups
    end
  )

  (
    def api_key(:list_groups) do
      16
    end

    def api_key(16) do
      :list_groups
    end
  )

  (
    def api_key(:sasl_handshake) do
      17
    end

    def api_key(17) do
      :sasl_handshake
    end
  )

  (
    def api_key(:api_versions) do
      18
    end

    def api_key(18) do
      :api_versions
    end
  )

  (
    def api_key(:create_topics) do
      19
    end

    def api_key(19) do
      :create_topics
    end
  )

  (
    def api_key(:delete_topics) do
      20
    end

    def api_key(20) do
      :delete_topics
    end
  )

  (
    def api_key(:delete_records) do
      21
    end

    def api_key(21) do
      :delete_records
    end
  )

  (
    def api_key(:init_producer_id) do
      22
    end

    def api_key(22) do
      :init_producer_id
    end
  )

  (
    def api_key(:offset_for_leader_epoch) do
      23
    end

    def api_key(23) do
      :offset_for_leader_epoch
    end
  )

  (
    def api_key(:add_partitions_to_txn) do
      24
    end

    def api_key(24) do
      :add_partitions_to_txn
    end
  )

  (
    def api_key(:add_offsets_to_txn) do
      25
    end

    def api_key(25) do
      :add_offsets_to_txn
    end
  )

  (
    def api_key(:end_txn) do
      26
    end

    def api_key(26) do
      :end_txn
    end
  )

  (
    def api_key(:txn_offset_commit) do
      28
    end

    def api_key(28) do
      :txn_offset_commit
    end
  )

  (
    def api_key(:describe_acls) do
      29
    end

    def api_key(29) do
      :describe_acls
    end
  )

  (
    def api_key(:create_acls) do
      30
    end

    def api_key(30) do
      :create_acls
    end
  )

  (
    def api_key(:delete_acls) do
      31
    end

    def api_key(31) do
      :delete_acls
    end
  )

  (
    def api_key(:describe_configs) do
      32
    end

    def api_key(32) do
      :describe_configs
    end
  )

  (
    def api_key(:alter_configs) do
      33
    end

    def api_key(33) do
      :alter_configs
    end
  )

  (
    def api_key(:alter_replica_log_dirs) do
      34
    end

    def api_key(34) do
      :alter_replica_log_dirs
    end
  )

  (
    def api_key(:describe_log_dirs) do
      35
    end

    def api_key(35) do
      :describe_log_dirs
    end
  )

  (
    def api_key(:sasl_authenticate) do
      36
    end

    def api_key(36) do
      :sasl_authenticate
    end
  )

  (
    def api_key(:create_partitions) do
      37
    end

    def api_key(37) do
      :create_partitions
    end
  )

  (
    def api_key(:create_delegation_token) do
      38
    end

    def api_key(38) do
      :create_delegation_token
    end
  )

  (
    def api_key(:renew_delegation_token) do
      39
    end

    def api_key(39) do
      :renew_delegation_token
    end
  )

  (
    def api_key(:expire_delegation_token) do
      40
    end

    def api_key(40) do
      :expire_delegation_token
    end
  )

  (
    def api_key(:describe_delegation_token) do
      41
    end

    def api_key(41) do
      :describe_delegation_token
    end
  )

  (
    def api_key(:delete_groups) do
      42
    end

    def api_key(42) do
      :delete_groups
    end
  )

  (
    def api_key(:elect_leaders) do
      43
    end

    def api_key(43) do
      :elect_leaders
    end
  )

  (
    def api_key(:incremental_alter_configs) do
      44
    end

    def api_key(44) do
      :incremental_alter_configs
    end
  )

  (
    def api_key(:alter_partition_reassignments) do
      45
    end

    def api_key(45) do
      :alter_partition_reassignments
    end
  )

  (
    def api_key(:list_partition_reassignments) do
      46
    end

    def api_key(46) do
      :list_partition_reassignments
    end
  )

  (
    def api_key(:offset_delete) do
      47
    end

    def api_key(47) do
      :offset_delete
    end
  )

  def request_schema(:produce, 0) do
    [
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 1) do
    [
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 2) do
    [
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 3) do
    [
      transactional_id: :nullable_string,
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 4) do
    [
      transactional_id: :nullable_string,
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 5) do
    [
      transactional_id: :nullable_string,
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 6) do
    [
      transactional_id: :nullable_string,
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 7) do
    [
      transactional_id: :nullable_string,
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:produce, 8) do
    [
      transactional_id: :nullable_string,
      acks: :int16,
      timeout: :int32,
      topic_data:
        {:array, topic: :string, data: {:array, partition: :int32, record_set: :records}}
    ]
  end

  def request_schema(:fetch, 0) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, fetch_offset: :int64, partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 1) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, fetch_offset: :int64, partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 2) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, fetch_offset: :int64, partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 3) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, fetch_offset: :int64, partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 4) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, fetch_offset: :int64, partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 5) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 6) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 7) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      session_id: :int32,
      session_epoch: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}},
      forgotten_topics_data:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 8) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      session_id: :int32,
      session_epoch: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}},
      forgotten_topics_data:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 9) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      session_id: :int32,
      session_epoch: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            current_leader_epoch: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}},
      forgotten_topics_data:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            current_leader_epoch: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 10) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      session_id: :int32,
      session_epoch: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            current_leader_epoch: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}},
      forgotten_topics_data:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            current_leader_epoch: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}}
    ]
  end

  def request_schema(:fetch, 11) do
    [
      replica_id: :int32,
      max_wait_time: :int32,
      min_bytes: :int32,
      max_bytes: :int32,
      isolation_level: :int8,
      session_id: :int32,
      session_epoch: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            current_leader_epoch: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}},
      forgotten_topics_data:
        {:array,
         topic: :string,
         partitions:
           {:array,
            partition: :int32,
            current_leader_epoch: :int32,
            fetch_offset: :int64,
            log_start_offset: :int64,
            partition_max_bytes: :int32}},
      rack_id: :string
    ]
  end

  def request_schema(:list_offsets, 0) do
    [
      replica_id: :int32,
      topics:
        {:array,
         topic: :string,
         partitions: {:array, partition: :int32, timestamp: :int64, max_num_offsets: :int32}}
    ]
  end

  def request_schema(:list_offsets, 1) do
    [
      replica_id: :int32,
      topics: {:array, topic: :string, partitions: {:array, partition: :int32, timestamp: :int64}}
    ]
  end

  def request_schema(:list_offsets, 2) do
    [
      replica_id: :int32,
      isolation_level: :int8,
      topics: {:array, topic: :string, partitions: {:array, partition: :int32, timestamp: :int64}}
    ]
  end

  def request_schema(:list_offsets, 3) do
    [
      replica_id: :int32,
      isolation_level: :int8,
      topics: {:array, topic: :string, partitions: {:array, partition: :int32, timestamp: :int64}}
    ]
  end

  def request_schema(:list_offsets, 4) do
    [
      replica_id: :int32,
      isolation_level: :int8,
      topics:
        {:array,
         topic: :string,
         partitions: {:array, partition: :int32, current_leader_epoch: :int32, timestamp: :int64}}
    ]
  end

  def request_schema(:list_offsets, 5) do
    [
      replica_id: :int32,
      isolation_level: :int8,
      topics:
        {:array,
         topic: :string,
         partitions: {:array, partition: :int32, current_leader_epoch: :int32, timestamp: :int64}}
    ]
  end

  def request_schema(:metadata, 0) do
    [topics: {:array, name: :string}]
  end

  def request_schema(:metadata, 1) do
    [topics: {:array, name: :string}]
  end

  def request_schema(:metadata, 2) do
    [topics: {:array, name: :string}]
  end

  def request_schema(:metadata, 3) do
    [topics: {:array, name: :string}]
  end

  def request_schema(:metadata, 4) do
    [topics: {:array, name: :string}, allow_auto_topic_creation: :boolean]
  end

  def request_schema(:metadata, 5) do
    [topics: {:array, name: :string}, allow_auto_topic_creation: :boolean]
  end

  def request_schema(:metadata, 6) do
    [topics: {:array, name: :string}, allow_auto_topic_creation: :boolean]
  end

  def request_schema(:metadata, 7) do
    [topics: {:array, name: :string}, allow_auto_topic_creation: :boolean]
  end

  def request_schema(:metadata, 8) do
    [
      topics: {:array, name: :string},
      allow_auto_topic_creation: :boolean,
      include_cluster_authorized_operations: :boolean,
      include_topic_authorized_operations: :boolean
    ]
  end

  def request_schema(:metadata, 9) do
    [
      topics: {:compact_array, name: :compact_string, tagged_fields: :tagged_fields},
      allow_auto_topic_creation: :boolean,
      include_cluster_authorized_operations: :boolean,
      include_topic_authorized_operations: :boolean,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:offset_commit, 0) do
    [
      group_id: :string,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            committed_metadata: :nullable_string}}
    ]
  end

  def request_schema(:offset_commit, 1) 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

  def request_schema(:offset_commit, 2) 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

  def request_schema(:offset_commit, 3) 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

  def request_schema(:offset_commit, 4) 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

  def request_schema(:offset_commit, 5) 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

  def request_schema(:offset_commit, 6) 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

  def request_schema(:offset_commit, 7) 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

  def request_schema(:offset_commit, 8) 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

  def request_schema(:offset_fetch, 0) do
    [group_id: :string, topics: {:array, name: :string, partition_indexes: {:array, :int32}}]
  end

  def request_schema(:offset_fetch, 1) do
    [group_id: :string, topics: {:array, name: :string, partition_indexes: {:array, :int32}}]
  end

  def request_schema(:offset_fetch, 2) do
    [group_id: :string, topics: {:array, name: :string, partition_indexes: {:array, :int32}}]
  end

  def request_schema(:offset_fetch, 3) do
    [group_id: :string, topics: {:array, name: :string, partition_indexes: {:array, :int32}}]
  end

  def request_schema(:offset_fetch, 4) do
    [group_id: :string, topics: {:array, name: :string, partition_indexes: {:array, :int32}}]
  end

  def request_schema(:offset_fetch, 5) do
    [group_id: :string, topics: {:array, name: :string, partition_indexes: {:array, :int32}}]
  end

  def request_schema(:offset_fetch, 6) do
    [
      group_id: :compact_string,
      topics:
        {:compact_array,
         name: :compact_string,
         partition_indexes: {:compact_array, :int32},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:find_coordinator, 0) do
    [key: :string]
  end

  def request_schema(:find_coordinator, 1) do
    [key: :string, key_type: :int8]
  end

  def request_schema(:find_coordinator, 2) do
    [key: :string, key_type: :int8]
  end

  def request_schema(:find_coordinator, 3) do
    [key: :compact_string, key_type: :int8, tagged_fields: :tagged_fields]
  end

  def request_schema(:join_group, 0) do
    [
      group_id: :string,
      session_timeout_ms: :int32,
      member_id: :string,
      protocol_type: :string,
      protocols: {:array, name: :string, metadata: :bytes}
    ]
  end

  def request_schema(:join_group, 1) do
    [
      group_id: :string,
      session_timeout_ms: :int32,
      rebalance_timeout_ms: :int32,
      member_id: :string,
      protocol_type: :string,
      protocols: {:array, name: :string, metadata: :bytes}
    ]
  end

  def request_schema(:join_group, 2) do
    [
      group_id: :string,
      session_timeout_ms: :int32,
      rebalance_timeout_ms: :int32,
      member_id: :string,
      protocol_type: :string,
      protocols: {:array, name: :string, metadata: :bytes}
    ]
  end

  def request_schema(:join_group, 3) do
    [
      group_id: :string,
      session_timeout_ms: :int32,
      rebalance_timeout_ms: :int32,
      member_id: :string,
      protocol_type: :string,
      protocols: {:array, name: :string, metadata: :bytes}
    ]
  end

  def request_schema(:join_group, 4) do
    [
      group_id: :string,
      session_timeout_ms: :int32,
      rebalance_timeout_ms: :int32,
      member_id: :string,
      protocol_type: :string,
      protocols: {:array, name: :string, metadata: :bytes}
    ]
  end

  def request_schema(:join_group, 5) do
    [
      group_id: :string,
      session_timeout_ms: :int32,
      rebalance_timeout_ms: :int32,
      member_id: :string,
      group_instance_id: :nullable_string,
      protocol_type: :string,
      protocols: {:array, name: :string, metadata: :bytes}
    ]
  end

  def request_schema(:join_group, 6) do
    [
      group_id: :compact_string,
      session_timeout_ms: :int32,
      rebalance_timeout_ms: :int32,
      member_id: :compact_string,
      group_instance_id: :compact_nullable_string,
      protocol_type: :compact_string,
      protocols:
        {:compact_array,
         name: :compact_string, metadata: :compact_bytes, tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:heartbeat, 0) do
    [group_id: :string, generation_id: :int32, member_id: :string]
  end

  def request_schema(:heartbeat, 1) do
    [group_id: :string, generation_id: :int32, member_id: :string]
  end

  def request_schema(:heartbeat, 2) do
    [group_id: :string, generation_id: :int32, member_id: :string]
  end

  def request_schema(:heartbeat, 3) do
    [
      group_id: :string,
      generation_id: :int32,
      member_id: :string,
      group_instance_id: :nullable_string
    ]
  end

  def request_schema(:heartbeat, 4) do
    [
      group_id: :compact_string,
      generation_id: :int32,
      member_id: :compact_string,
      group_instance_id: :compact_nullable_string,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:leave_group, 0) do
    [group_id: :string, member_id: :string]
  end

  def request_schema(:leave_group, 1) do
    [group_id: :string, member_id: :string]
  end

  def request_schema(:leave_group, 2) do
    [group_id: :string, member_id: :string]
  end

  def request_schema(:leave_group, 3) do
    [
      group_id: :string,
      members: {:array, member_id: :string, group_instance_id: :nullable_string}
    ]
  end

  def request_schema(:leave_group, 4) do
    [
      group_id: :compact_string,
      members:
        {:compact_array,
         member_id: :compact_string,
         group_instance_id: :compact_nullable_string,
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:sync_group, 0) do
    [
      group_id: :string,
      generation_id: :int32,
      member_id: :string,
      assignments: {:array, member_id: :string, assignment: :bytes}
    ]
  end

  def request_schema(:sync_group, 1) do
    [
      group_id: :string,
      generation_id: :int32,
      member_id: :string,
      assignments: {:array, member_id: :string, assignment: :bytes}
    ]
  end

  def request_schema(:sync_group, 2) do
    [
      group_id: :string,
      generation_id: :int32,
      member_id: :string,
      assignments: {:array, member_id: :string, assignment: :bytes}
    ]
  end

  def request_schema(:sync_group, 3) do
    [
      group_id: :string,
      generation_id: :int32,
      member_id: :string,
      group_instance_id: :nullable_string,
      assignments: {:array, member_id: :string, assignment: :bytes}
    ]
  end

  def request_schema(:sync_group, 4) do
    [
      group_id: :compact_string,
      generation_id: :int32,
      member_id: :compact_string,
      group_instance_id: :compact_nullable_string,
      assignments:
        {:compact_array,
         member_id: :compact_string, assignment: :compact_bytes, tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:describe_groups, 0) do
    [groups: {:array, :string}]
  end

  def request_schema(:describe_groups, 1) do
    [groups: {:array, :string}]
  end

  def request_schema(:describe_groups, 2) do
    [groups: {:array, :string}]
  end

  def request_schema(:describe_groups, 3) do
    [groups: {:array, :string}, include_authorized_operations: :boolean]
  end

  def request_schema(:describe_groups, 4) do
    [groups: {:array, :string}, include_authorized_operations: :boolean]
  end

  def request_schema(:describe_groups, 5) do
    [
      groups: {:compact_array, :compact_string},
      include_authorized_operations: :boolean,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:list_groups, 0) do
    []
  end

  def request_schema(:list_groups, 1) do
    []
  end

  def request_schema(:list_groups, 2) do
    []
  end

  def request_schema(:list_groups, 3) do
    [tagged_fields: :tagged_fields]
  end

  def request_schema(:sasl_handshake, 0) do
    [mechanism: :string]
  end

  def request_schema(:sasl_handshake, 1) do
    [mechanism: :string]
  end

  def request_schema(:api_versions, 0) do
    []
  end

  def request_schema(:api_versions, 1) do
    []
  end

  def request_schema(:api_versions, 2) do
    []
  end

  def request_schema(:api_versions, 3) do
    [
      client_software_name: :compact_string,
      client_software_version: :compact_string,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:create_topics, 0) do
    [
      topics:
        {:array,
         name: :string,
         num_partitions: :int32,
         replication_factor: :int16,
         assignments: {:array, partition_index: :int32, broker_ids: {:array, :int32}},
         configs: {:array, name: :string, value: :nullable_string}},
      timeout_ms: :int32
    ]
  end

  def request_schema(:create_topics, 1) do
    [
      topics:
        {:array,
         name: :string,
         num_partitions: :int32,
         replication_factor: :int16,
         assignments: {:array, partition_index: :int32, broker_ids: {:array, :int32}},
         configs: {:array, name: :string, value: :nullable_string}},
      timeout_ms: :int32,
      validate_only: :boolean
    ]
  end

  def request_schema(:create_topics, 2) do
    [
      topics:
        {:array,
         name: :string,
         num_partitions: :int32,
         replication_factor: :int16,
         assignments: {:array, partition_index: :int32, broker_ids: {:array, :int32}},
         configs: {:array, name: :string, value: :nullable_string}},
      timeout_ms: :int32,
      validate_only: :boolean
    ]
  end

  def request_schema(:create_topics, 3) do
    [
      topics:
        {:array,
         name: :string,
         num_partitions: :int32,
         replication_factor: :int16,
         assignments: {:array, partition_index: :int32, broker_ids: {:array, :int32}},
         configs: {:array, name: :string, value: :nullable_string}},
      timeout_ms: :int32,
      validate_only: :boolean
    ]
  end

  def request_schema(:create_topics, 4) do
    [
      topics:
        {:array,
         name: :string,
         num_partitions: :int32,
         replication_factor: :int16,
         assignments: {:array, partition_index: :int32, broker_ids: {:array, :int32}},
         configs: {:array, name: :string, value: :nullable_string}},
      timeout_ms: :int32,
      validate_only: :boolean
    ]
  end

  def request_schema(:create_topics, 5) do
    [
      topics:
        {:compact_array,
         name: :compact_string,
         num_partitions: :int32,
         replication_factor: :int16,
         assignments:
           {:compact_array,
            partition_index: :int32,
            broker_ids: {:compact_array, :int32},
            tagged_fields: :tagged_fields},
         configs:
           {:compact_array,
            name: :compact_string, value: :compact_nullable_string, tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      timeout_ms: :int32,
      validate_only: :boolean,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:delete_topics, 0) do
    [topic_names: {:array, :string}, timeout_ms: :int32]
  end

  def request_schema(:delete_topics, 1) do
    [topic_names: {:array, :string}, timeout_ms: :int32]
  end

  def request_schema(:delete_topics, 2) do
    [topic_names: {:array, :string}, timeout_ms: :int32]
  end

  def request_schema(:delete_topics, 3) do
    [topic_names: {:array, :string}, timeout_ms: :int32]
  end

  def request_schema(:delete_topics, 4) do
    [
      topic_names: {:compact_array, :compact_string},
      timeout_ms: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:delete_records, 0) do
    [
      topics: {:array, topic: :string, partitions: {:array, partition: :int32, offset: :int64}},
      timeout: :int32
    ]
  end

  def request_schema(:delete_records, 1) do
    [
      topics: {:array, topic: :string, partitions: {:array, partition: :int32, offset: :int64}},
      timeout: :int32
    ]
  end

  def request_schema(:init_producer_id, 0) do
    [transactional_id: :nullable_string, transaction_timeout_ms: :int32]
  end

  def request_schema(:init_producer_id, 1) do
    [transactional_id: :nullable_string, transaction_timeout_ms: :int32]
  end

  def request_schema(:init_producer_id, 2) do
    [
      transactional_id: :compact_nullable_string,
      transaction_timeout_ms: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:offset_for_leader_epoch, 0) do
    [
      topics:
        {:array, topic: :string, partitions: {:array, partition: :int32, leader_epoch: :int32}}
    ]
  end

  def request_schema(:offset_for_leader_epoch, 1) do
    [
      topics:
        {:array, topic: :string, partitions: {:array, partition: :int32, leader_epoch: :int32}}
    ]
  end

  def request_schema(:offset_for_leader_epoch, 2) do
    [
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, current_leader_epoch: :int32, leader_epoch: :int32}}
    ]
  end

  def request_schema(:offset_for_leader_epoch, 3) do
    [
      replica_id: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array, partition: :int32, current_leader_epoch: :int32, leader_epoch: :int32}}
    ]
  end

  def request_schema(:add_partitions_to_txn, 0) do
    [
      transactional_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      topics: {:array, topic: :string, partitions: {:array, :int32}}
    ]
  end

  def request_schema(:add_partitions_to_txn, 1) do
    [
      transactional_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      topics: {:array, topic: :string, partitions: {:array, :int32}}
    ]
  end

  def request_schema(:add_offsets_to_txn, 0) do
    [transactional_id: :string, producer_id: :int64, producer_epoch: :int16, group_id: :string]
  end

  def request_schema(:add_offsets_to_txn, 1) do
    [transactional_id: :string, producer_id: :int64, producer_epoch: :int16, group_id: :string]
  end

  def request_schema(:end_txn, 0) do
    [
      transactional_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      transaction_result: :boolean
    ]
  end

  def request_schema(:end_txn, 1) do
    [
      transactional_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      transaction_result: :boolean
    ]
  end

  def request_schema(:txn_offset_commit, 0) do
    [
      transactional_id: :string,
      group_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            committed_metadata: :nullable_string}}
    ]
  end

  def request_schema(:txn_offset_commit, 1) do
    [
      transactional_id: :string,
      group_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            committed_metadata: :nullable_string}}
    ]
  end

  def request_schema(:txn_offset_commit, 2) do
    [
      transactional_id: :string,
      group_id: :string,
      producer_id: :int64,
      producer_epoch: :int16,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            committed_leader_epoch: :int32,
            committed_metadata: :nullable_string}}
    ]
  end

  def request_schema(:describe_acls, 0) do
    [
      resource_type: :int8,
      resource_name: :nullable_string,
      principal: :nullable_string,
      host: :nullable_string,
      operation: :int8,
      permission_type: :int8
    ]
  end

  def request_schema(:describe_acls, 1) do
    [
      resource_type: :int8,
      resource_name: :nullable_string,
      resource_pattern_type_filter: :int8,
      principal: :nullable_string,
      host: :nullable_string,
      operation: :int8,
      permission_type: :int8
    ]
  end

  def request_schema(:create_acls, 0) do
    [
      creations:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         principal: :string,
         host: :string,
         operation: :int8,
         permission_type: :int8}
    ]
  end

  def request_schema(:create_acls, 1) do
    [
      creations:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         resource_pattern_type: :int8,
         principal: :string,
         host: :string,
         operation: :int8,
         permission_type: :int8}
    ]
  end

  def request_schema(:delete_acls, 0) do
    [
      filters:
        {:array,
         resource_type: :int8,
         resource_name: :nullable_string,
         principal: :nullable_string,
         host: :nullable_string,
         operation: :int8,
         permission_type: :int8}
    ]
  end

  def request_schema(:delete_acls, 1) do
    [
      filters:
        {:array,
         resource_type: :int8,
         resource_name: :nullable_string,
         resource_pattern_type_filter: :int8,
         principal: :nullable_string,
         host: :nullable_string,
         operation: :int8,
         permission_type: :int8}
    ]
  end

  def request_schema(:describe_configs, 0) do
    [
      resources:
        {:array, resource_type: :int8, resource_name: :string, config_names: {:array, :string}}
    ]
  end

  def request_schema(:describe_configs, 1) do
    [
      resources:
        {:array, resource_type: :int8, resource_name: :string, config_names: {:array, :string}},
      include_synonyms: :boolean
    ]
  end

  def request_schema(:describe_configs, 2) do
    [
      resources:
        {:array, resource_type: :int8, resource_name: :string, config_names: {:array, :string}},
      include_synonyms: :boolean
    ]
  end

  def request_schema(:alter_configs, 0) do
    [
      resources:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         config_entries: {:array, config_name: :string, config_value: :nullable_string}},
      validate_only: :boolean
    ]
  end

  def request_schema(:alter_configs, 1) do
    [
      resources:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         config_entries: {:array, config_name: :string, config_value: :nullable_string}},
      validate_only: :boolean
    ]
  end

  def request_schema(:alter_replica_log_dirs, 0) do
    [
      log_dirs:
        {:array, log_dir: :string, topics: {:array, topic: :string, partitions: {:array, :int32}}}
    ]
  end

  def request_schema(:alter_replica_log_dirs, 1) do
    [
      log_dirs:
        {:array, log_dir: :string, topics: {:array, topic: :string, partitions: {:array, :int32}}}
    ]
  end

  def request_schema(:describe_log_dirs, 0) do
    [topics: {:array, topic: :string, partitions: {:array, :int32}}]
  end

  def request_schema(:describe_log_dirs, 1) do
    [topics: {:array, topic: :string, partitions: {:array, :int32}}]
  end

  def request_schema(:sasl_authenticate, 0) do
    [auth_bytes: :bytes]
  end

  def request_schema(:sasl_authenticate, 1) do
    [auth_bytes: :bytes]
  end

  def request_schema(:create_partitions, 0) do
    [
      topic_partitions:
        {:array,
         topic: :string, new_partitions: [count: :int32, assignment: {:array, {:array, :int32}}]},
      timeout: :int32,
      validate_only: :boolean
    ]
  end

  def request_schema(:create_partitions, 1) do
    [
      topic_partitions:
        {:array,
         topic: :string, new_partitions: [count: :int32, assignment: {:array, {:array, :int32}}]},
      timeout: :int32,
      validate_only: :boolean
    ]
  end

  def request_schema(:create_delegation_token, 0) do
    [
      renewers: {:array, principal_type: :string, principal_name: :string},
      max_lifetime_ms: :int64
    ]
  end

  def request_schema(:create_delegation_token, 1) do
    [
      renewers: {:array, principal_type: :string, principal_name: :string},
      max_lifetime_ms: :int64
    ]
  end

  def request_schema(:create_delegation_token, 2) do
    [
      renewers:
        {:compact_array,
         principal_type: :compact_string,
         principal_name: :compact_string,
         tagged_fields: :tagged_fields},
      max_lifetime_ms: :int64,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:renew_delegation_token, 0) do
    [hmac: :bytes, renew_period_ms: :int64]
  end

  def request_schema(:renew_delegation_token, 1) do
    [hmac: :bytes, renew_period_ms: :int64]
  end

  def request_schema(:expire_delegation_token, 0) do
    [hmac: :bytes, expiry_time_period_ms: :int64]
  end

  def request_schema(:expire_delegation_token, 1) do
    [hmac: :bytes, expiry_time_period_ms: :int64]
  end

  def request_schema(:describe_delegation_token, 0) do
    [owners: {:array, principal_type: :string, principal_name: :string}]
  end

  def request_schema(:describe_delegation_token, 1) do
    [owners: {:array, principal_type: :string, principal_name: :string}]
  end

  def request_schema(:delete_groups, 0) do
    [groups_names: {:array, :string}]
  end

  def request_schema(:delete_groups, 1) do
    [groups_names: {:array, :string}]
  end

  def request_schema(:delete_groups, 2) do
    [groups_names: {:compact_array, :compact_string}, tagged_fields: :tagged_fields]
  end

  def request_schema(:elect_leaders, 0) do
    [
      topic_partitions: {:array, topic: :string, partition_id: {:array, :int32}},
      timeout_ms: :int32
    ]
  end

  def request_schema(:elect_leaders, 1) do
    [
      election_type: :int8,
      topic_partitions: {:array, topic: :string, partition_id: {:array, :int32}},
      timeout_ms: :int32
    ]
  end

  def request_schema(:elect_leaders, 2) do
    [
      election_type: :int8,
      topic_partitions:
        {:compact_array,
         topic: :compact_string,
         partition_id: {:compact_array, :int32},
         tagged_fields: :tagged_fields},
      timeout_ms: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:incremental_alter_configs, 0) do
    [
      resources:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         configs: {:array, name: :string, config_operation: :int8, value: :nullable_string}},
      validate_only: :boolean
    ]
  end

  def request_schema(:incremental_alter_configs, 1) do
    [
      resources:
        {:compact_array,
         resource_type: :int8,
         resource_name: :compact_string,
         configs:
           {:compact_array,
            name: :compact_string,
            config_operation: :int8,
            value: :compact_nullable_string,
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      validate_only: :boolean,
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:alter_partition_reassignments, 0) do
    [
      timeout_ms: :int32,
      topics:
        {:compact_array,
         name: :compact_string,
         partitions:
           {:compact_array,
            partition_index: :int32,
            replicas: {:compact_array, :int32},
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:list_partition_reassignments, 0) do
    [
      timeout_ms: :int32,
      topics:
        {:compact_array,
         name: :compact_string,
         partition_indexes: {:compact_array, :int32},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def request_schema(:offset_delete, 0) do
    [
      group_id: :string,
      topics: {:array, name: :string, partitions: {:array, partition_index: :int32}}
    ]
  end

  def response_schema(:produce, 0) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses: {:array, partition: :int32, error_code: :int16, base_offset: :int64}}
    ]
  end

  def response_schema(:produce, 1) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses: {:array, partition: :int32, error_code: :int16, base_offset: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 2) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32, error_code: :int16, base_offset: :int64, log_append_time: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 3) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32, error_code: :int16, base_offset: :int64, log_append_time: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 4) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32, error_code: :int16, base_offset: :int64, log_append_time: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 5) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32,
            error_code: :int16,
            base_offset: :int64,
            log_append_time: :int64,
            log_start_offset: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 6) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32,
            error_code: :int16,
            base_offset: :int64,
            log_append_time: :int64,
            log_start_offset: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 7) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32,
            error_code: :int16,
            base_offset: :int64,
            log_append_time: :int64,
            log_start_offset: :int64}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:produce, 8) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32,
            error_code: :int16,
            base_offset: :int64,
            log_append_time: :int64,
            log_start_offset: :int64,
            record_errors:
              {:array, batch_index: :int32, batch_index_error_message: :nullable_string},
            error_message: :nullable_string}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:fetch, 0) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [partition: :int32, error_code: :int16, high_watermark: :int64],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 1) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [partition: :int32, error_code: :int16, high_watermark: :int64],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 2) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [partition: :int32, error_code: :int16, high_watermark: :int64],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 3) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [partition: :int32, error_code: :int16, high_watermark: :int64],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 4) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 5) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 6) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 7) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      session_id: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 8) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      session_id: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 9) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      session_id: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 10) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      session_id: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64}
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:fetch, 11) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      session_id: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition_header: [
              partition: :int32,
              error_code: :int16,
              high_watermark: :int64,
              last_stable_offset: :int64,
              log_start_offset: :int64,
              aborted_transactions: {:array, producer_id: :int64, first_offset: :int64},
              preferred_read_replica: :int32
            ],
            record_set: :records}}
    ]
  end

  def response_schema(:list_offsets, 0) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array, partition: :int32, error_code: :int16, offsets: {:array, :int64}}}
    ]
  end

  def response_schema(:list_offsets, 1) do
    [
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array, partition: :int32, error_code: :int16, timestamp: :int64, offset: :int64}}
    ]
  end

  def response_schema(:list_offsets, 2) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array, partition: :int32, error_code: :int16, timestamp: :int64, offset: :int64}}
    ]
  end

  def response_schema(:list_offsets, 3) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array, partition: :int32, error_code: :int16, timestamp: :int64, offset: :int64}}
    ]
  end

  def response_schema(:list_offsets, 4) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32,
            error_code: :int16,
            timestamp: :int64,
            offset: :int64,
            leader_epoch: :int32}}
    ]
  end

  def response_schema(:list_offsets, 5) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         topic: :string,
         partition_responses:
           {:array,
            partition: :int32,
            error_code: :int16,
            timestamp: :int64,
            offset: :int64,
            leader_epoch: :int32}}
    ]
  end

  def response_schema(:metadata, 0) do
    [
      brokers: {:array, node_id: :int32, host: :string, port: :int32},
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 1) do
    [
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 2) do
    [
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 3) do
    [
      throttle_time_ms: :int32,
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 4) do
    [
      throttle_time_ms: :int32,
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 5) do
    [
      throttle_time_ms: :int32,
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32},
            offline_replicas: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 6) do
    [
      throttle_time_ms: :int32,
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32},
            offline_replicas: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 7) do
    [
      throttle_time_ms: :int32,
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            leader_epoch: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32},
            offline_replicas: {:array, :int32}}}
    ]
  end

  def response_schema(:metadata, 8) do
    [
      throttle_time_ms: :int32,
      brokers: {:array, node_id: :int32, host: :string, port: :int32, rack: :nullable_string},
      cluster_id: :nullable_string,
      controller_id: :int32,
      topics:
        {:array,
         error_code: :int16,
         name: :string,
         is_internal: :boolean,
         partitions:
           {:array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            leader_epoch: :int32,
            replica_nodes: {:array, :int32},
            isr_nodes: {:array, :int32},
            offline_replicas: {:array, :int32}},
         topic_authorized_operations: :int32},
      cluster_authorized_operations: :int32
    ]
  end

  def response_schema(:metadata, 9) do
    [
      throttle_time_ms: :int32,
      brokers:
        {:compact_array,
         node_id: :int32,
         host: :compact_string,
         port: :int32,
         rack: :compact_nullable_string,
         tagged_fields: :tagged_fields},
      cluster_id: :compact_nullable_string,
      controller_id: :int32,
      topics:
        {:compact_array,
         error_code: :int16,
         name: :compact_string,
         is_internal: :boolean,
         partitions:
           {:compact_array,
            error_code: :int16,
            partition_index: :int32,
            leader_id: :int32,
            leader_epoch: :int32,
            replica_nodes: {:compact_array, :int32},
            isr_nodes: {:compact_array, :int32},
            offline_replicas: {:compact_array, :int32},
            tagged_fields: :tagged_fields},
         topic_authorized_operations: :int32,
         tagged_fields: :tagged_fields},
      cluster_authorized_operations: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:offset_commit, 0) do
    [
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 1) do
    [
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 2) do
    [
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 3) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 4) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 5) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 6) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 7) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:offset_commit, 8) 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

  def response_schema(:offset_fetch, 0) do
    [
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            metadata: :nullable_string,
            error_code: :int16}}
    ]
  end

  def response_schema(:offset_fetch, 1) do
    [
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            metadata: :nullable_string,
            error_code: :int16}}
    ]
  end

  def response_schema(:offset_fetch, 2) do
    [
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            metadata: :nullable_string,
            error_code: :int16}},
      error_code: :int16
    ]
  end

  def response_schema(:offset_fetch, 3) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            metadata: :nullable_string,
            error_code: :int16}},
      error_code: :int16
    ]
  end

  def response_schema(:offset_fetch, 4) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            metadata: :nullable_string,
            error_code: :int16}},
      error_code: :int16
    ]
  end

  def response_schema(:offset_fetch, 5) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         name: :string,
         partitions:
           {:array,
            partition_index: :int32,
            committed_offset: :int64,
            committed_leader_epoch: :int32,
            metadata: :nullable_string,
            error_code: :int16}},
      error_code: :int16
    ]
  end

  def response_schema(:offset_fetch, 6) do
    [
      throttle_time_ms: :int32,
      topics:
        {:compact_array,
         name: :compact_string,
         partitions:
           {:compact_array,
            partition_index: :int32,
            committed_offset: :int64,
            committed_leader_epoch: :int32,
            metadata: :compact_nullable_string,
            error_code: :int16,
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      error_code: :int16,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:find_coordinator, 0) do
    [error_code: :int16, node_id: :int32, host: :string, port: :int32]
  end

  def response_schema(:find_coordinator, 1) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :nullable_string,
      node_id: :int32,
      host: :string,
      port: :int32
    ]
  end

  def response_schema(:find_coordinator, 2) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :nullable_string,
      node_id: :int32,
      host: :string,
      port: :int32
    ]
  end

  def response_schema(:find_coordinator, 3) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :compact_nullable_string,
      node_id: :int32,
      host: :compact_string,
      port: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:join_group, 0) do
    [
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :string,
      leader: :string,
      member_id: :string,
      members: {:array, member_id: :string, metadata: :bytes}
    ]
  end

  def response_schema(:join_group, 1) do
    [
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :string,
      leader: :string,
      member_id: :string,
      members: {:array, member_id: :string, metadata: :bytes}
    ]
  end

  def response_schema(:join_group, 2) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :string,
      leader: :string,
      member_id: :string,
      members: {:array, member_id: :string, metadata: :bytes}
    ]
  end

  def response_schema(:join_group, 3) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :string,
      leader: :string,
      member_id: :string,
      members: {:array, member_id: :string, metadata: :bytes}
    ]
  end

  def response_schema(:join_group, 4) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :string,
      leader: :string,
      member_id: :string,
      members: {:array, member_id: :string, metadata: :bytes}
    ]
  end

  def response_schema(:join_group, 5) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :string,
      leader: :string,
      member_id: :string,
      members: {:array, member_id: :string, group_instance_id: :nullable_string, metadata: :bytes}
    ]
  end

  def response_schema(:join_group, 6) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      generation_id: :int32,
      protocol_name: :compact_string,
      leader: :compact_string,
      member_id: :compact_string,
      members:
        {:compact_array,
         member_id: :compact_string,
         group_instance_id: :compact_nullable_string,
         metadata: :compact_bytes,
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:heartbeat, 0) do
    [error_code: :int16]
  end

  def response_schema(:heartbeat, 1) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:heartbeat, 2) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:heartbeat, 3) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:heartbeat, 4) do
    [throttle_time_ms: :int32, error_code: :int16, tagged_fields: :tagged_fields]
  end

  def response_schema(:leave_group, 0) do
    [error_code: :int16]
  end

  def response_schema(:leave_group, 1) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:leave_group, 2) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:leave_group, 3) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      members:
        {:array, member_id: :string, group_instance_id: :nullable_string, error_code: :int16}
    ]
  end

  def response_schema(:leave_group, 4) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      members:
        {:compact_array,
         member_id: :compact_string,
         group_instance_id: :compact_nullable_string,
         error_code: :int16,
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:sync_group, 0) do
    [error_code: :int16, assignment: :bytes]
  end

  def response_schema(:sync_group, 1) do
    [throttle_time_ms: :int32, error_code: :int16, assignment: :bytes]
  end

  def response_schema(:sync_group, 2) do
    [throttle_time_ms: :int32, error_code: :int16, assignment: :bytes]
  end

  def response_schema(:sync_group, 3) do
    [throttle_time_ms: :int32, error_code: :int16, assignment: :bytes]
  end

  def response_schema(:sync_group, 4) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      assignment: :compact_bytes,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:describe_groups, 0) do
    [
      groups:
        {:array,
         error_code: :int16,
         group_id: :string,
         group_state: :string,
         protocol_type: :string,
         protocol_data: :string,
         members:
           {:array,
            member_id: :string,
            client_id: :string,
            client_host: :string,
            member_metadata: :bytes,
            member_assignment: :bytes}}
    ]
  end

  def response_schema(:describe_groups, 1) do
    [
      throttle_time_ms: :int32,
      groups:
        {:array,
         error_code: :int16,
         group_id: :string,
         group_state: :string,
         protocol_type: :string,
         protocol_data: :string,
         members:
           {:array,
            member_id: :string,
            client_id: :string,
            client_host: :string,
            member_metadata: :bytes,
            member_assignment: :bytes}}
    ]
  end

  def response_schema(:describe_groups, 2) do
    [
      throttle_time_ms: :int32,
      groups:
        {:array,
         error_code: :int16,
         group_id: :string,
         group_state: :string,
         protocol_type: :string,
         protocol_data: :string,
         members:
           {:array,
            member_id: :string,
            client_id: :string,
            client_host: :string,
            member_metadata: :bytes,
            member_assignment: :bytes}}
    ]
  end

  def response_schema(:describe_groups, 3) do
    [
      throttle_time_ms: :int32,
      groups:
        {:array,
         error_code: :int16,
         group_id: :string,
         group_state: :string,
         protocol_type: :string,
         protocol_data: :string,
         members:
           {:array,
            member_id: :string,
            client_id: :string,
            client_host: :string,
            member_metadata: :bytes,
            member_assignment: :bytes},
         authorized_operations: :int32}
    ]
  end

  def response_schema(:describe_groups, 4) do
    [
      throttle_time_ms: :int32,
      groups:
        {:array,
         error_code: :int16,
         group_id: :string,
         group_state: :string,
         protocol_type: :string,
         protocol_data: :string,
         members:
           {:array,
            member_id: :string,
            group_instance_id: :nullable_string,
            client_id: :string,
            client_host: :string,
            member_metadata: :bytes,
            member_assignment: :bytes},
         authorized_operations: :int32}
    ]
  end

  def response_schema(:describe_groups, 5) do
    [
      throttle_time_ms: :int32,
      groups:
        {:compact_array,
         error_code: :int16,
         group_id: :compact_string,
         group_state: :compact_string,
         protocol_type: :compact_string,
         protocol_data: :compact_string,
         members:
           {:compact_array,
            member_id: :compact_string,
            group_instance_id: :compact_nullable_string,
            client_id: :compact_string,
            client_host: :compact_string,
            member_metadata: :compact_bytes,
            member_assignment: :compact_bytes,
            tagged_fields: :tagged_fields},
         authorized_operations: :int32,
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:list_groups, 0) do
    [error_code: :int16, groups: {:array, group_id: :string, protocol_type: :string}]
  end

  def response_schema(:list_groups, 1) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      groups: {:array, group_id: :string, protocol_type: :string}
    ]
  end

  def response_schema(:list_groups, 2) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      groups: {:array, group_id: :string, protocol_type: :string}
    ]
  end

  def response_schema(:list_groups, 3) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      groups:
        {:compact_array,
         group_id: :compact_string, protocol_type: :compact_string, tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:sasl_handshake, 0) do
    [error_code: :int16, mechanisms: {:array, :string}]
  end

  def response_schema(:sasl_handshake, 1) do
    [error_code: :int16, mechanisms: {:array, :string}]
  end

  def response_schema(:api_versions, 0) do
    [
      error_code: :int16,
      api_keys: {:array, api_key: :int16, min_version: :int16, max_version: :int16}
    ]
  end

  def response_schema(:api_versions, 1) do
    [
      error_code: :int16,
      api_keys: {:array, api_key: :int16, min_version: :int16, max_version: :int16},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:api_versions, 2) do
    [
      error_code: :int16,
      api_keys: {:array, api_key: :int16, min_version: :int16, max_version: :int16},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:api_versions, 3) do
    [
      error_code: :int16,
      api_keys:
        {:compact_array,
         api_key: :int16, min_version: :int16, max_version: :int16, tagged_fields: :tagged_fields},
      throttle_time_ms: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:create_topics, 0) do
    [topics: {:array, name: :string, error_code: :int16}]
  end

  def response_schema(:create_topics, 1) do
    [topics: {:array, name: :string, error_code: :int16, error_message: :nullable_string}]
  end

  def response_schema(:create_topics, 2) do
    [
      throttle_time_ms: :int32,
      topics: {:array, name: :string, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:create_topics, 3) do
    [
      throttle_time_ms: :int32,
      topics: {:array, name: :string, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:create_topics, 4) do
    [
      throttle_time_ms: :int32,
      topics: {:array, name: :string, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:create_topics, 5) do
    [
      throttle_time_ms: :int32,
      topics:
        {:compact_array,
         name: :compact_string,
         error_code: :int16,
         error_message: :compact_nullable_string,
         num_partitions: :int32,
         replication_factor: :int16,
         configs:
           {:compact_array,
            name: :compact_string,
            value: :compact_nullable_string,
            read_only: :boolean,
            config_source: :int8,
            is_sensitive: :boolean,
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:delete_topics, 0) do
    [responses: {:array, name: :string, error_code: :int16}]
  end

  def response_schema(:delete_topics, 1) do
    [throttle_time_ms: :int32, responses: {:array, name: :string, error_code: :int16}]
  end

  def response_schema(:delete_topics, 2) do
    [throttle_time_ms: :int32, responses: {:array, name: :string, error_code: :int16}]
  end

  def response_schema(:delete_topics, 3) do
    [throttle_time_ms: :int32, responses: {:array, name: :string, error_code: :int16}]
  end

  def response_schema(:delete_topics, 4) do
    [
      throttle_time_ms: :int32,
      responses:
        {:compact_array, name: :compact_string, error_code: :int16, tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:delete_records, 0) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         topic: :string,
         partitions: {:array, partition: :int32, low_watermark: :int64, error_code: :int16}}
    ]
  end

  def response_schema(:delete_records, 1) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         topic: :string,
         partitions: {:array, partition: :int32, low_watermark: :int64, error_code: :int16}}
    ]
  end

  def response_schema(:init_producer_id, 0) do
    [throttle_time_ms: :int32, error_code: :int16, producer_id: :int64, producer_epoch: :int16]
  end

  def response_schema(:init_producer_id, 1) do
    [throttle_time_ms: :int32, error_code: :int16, producer_id: :int64, producer_epoch: :int16]
  end

  def response_schema(:init_producer_id, 2) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      producer_id: :int64,
      producer_epoch: :int16,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:offset_for_leader_epoch, 0) do
    [
      topics:
        {:array,
         topic: :string,
         partitions: {:array, error_code: :int16, partition: :int32, end_offset: :int64}}
    ]
  end

  def response_schema(:offset_for_leader_epoch, 1) do
    [
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            error_code: :int16, partition: :int32, leader_epoch: :int32, end_offset: :int64}}
    ]
  end

  def response_schema(:offset_for_leader_epoch, 2) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            error_code: :int16, partition: :int32, leader_epoch: :int32, end_offset: :int64}}
    ]
  end

  def response_schema(:offset_for_leader_epoch, 3) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array,
         topic: :string,
         partitions:
           {:array,
            error_code: :int16, partition: :int32, leader_epoch: :int32, end_offset: :int64}}
    ]
  end

  def response_schema(:add_partitions_to_txn, 0) do
    [
      throttle_time_ms: :int32,
      errors:
        {:array,
         topic: :string, partition_errors: {:array, partition: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:add_partitions_to_txn, 1) do
    [
      throttle_time_ms: :int32,
      errors:
        {:array,
         topic: :string, partition_errors: {:array, partition: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:add_offsets_to_txn, 0) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:add_offsets_to_txn, 1) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:end_txn, 0) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:end_txn, 1) do
    [throttle_time_ms: :int32, error_code: :int16]
  end

  def response_schema(:txn_offset_commit, 0) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:txn_offset_commit, 1) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:txn_offset_commit, 2) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:describe_acls, 0) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :nullable_string,
      resources:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         acls:
           {:array, principal: :string, host: :string, operation: :int8, permission_type: :int8}}
    ]
  end

  def response_schema(:describe_acls, 1) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :nullable_string,
      resources:
        {:array,
         resource_type: :int8,
         resource_name: :string,
         resource_pattern_type: :int8,
         acls:
           {:array, principal: :string, host: :string, operation: :int8, permission_type: :int8}}
    ]
  end

  def response_schema(:create_acls, 0) do
    [
      throttle_time_ms: :int32,
      creation_responses: {:array, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:create_acls, 1) do
    [
      throttle_time_ms: :int32,
      creation_responses: {:array, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:delete_acls, 0) do
    [
      throttle_time_ms: :int32,
      filter_responses:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         matching_acls:
           {:array,
            error_code: :int16,
            error_message: :nullable_string,
            resource_type: :int8,
            resource_name: :string,
            principal: :string,
            host: :string,
            operation: :int8,
            permission_type: :int8}}
    ]
  end

  def response_schema(:delete_acls, 1) do
    [
      throttle_time_ms: :int32,
      filter_responses:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         matching_acls:
           {:array,
            error_code: :int16,
            error_message: :nullable_string,
            resource_type: :int8,
            resource_name: :string,
            resource_pattern_type: :int8,
            principal: :string,
            host: :string,
            operation: :int8,
            permission_type: :int8}}
    ]
  end

  def response_schema(:describe_configs, 0) do
    [
      throttle_time_ms: :int32,
      resources:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         resource_type: :int8,
         resource_name: :string,
         config_entries:
           {:array,
            config_name: :string,
            config_value: :nullable_string,
            read_only: :boolean,
            is_default: :boolean,
            is_sensitive: :boolean}}
    ]
  end

  def response_schema(:describe_configs, 1) do
    [
      throttle_time_ms: :int32,
      resources:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         resource_type: :int8,
         resource_name: :string,
         config_entries:
           {:array,
            config_name: :string,
            config_value: :nullable_string,
            read_only: :boolean,
            config_source: :int8,
            is_sensitive: :boolean,
            config_synonyms:
              {:array, config_name: :string, config_value: :nullable_string, config_source: :int8}}}
    ]
  end

  def response_schema(:describe_configs, 2) do
    [
      throttle_time_ms: :int32,
      resources:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         resource_type: :int8,
         resource_name: :string,
         config_entries:
           {:array,
            config_name: :string,
            config_value: :nullable_string,
            read_only: :boolean,
            config_source: :int8,
            is_sensitive: :boolean,
            config_synonyms:
              {:array, config_name: :string, config_value: :nullable_string, config_source: :int8}}}
    ]
  end

  def response_schema(:alter_configs, 0) do
    [
      throttle_time_ms: :int32,
      resources:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         resource_type: :int8,
         resource_name: :string}
    ]
  end

  def response_schema(:alter_configs, 1) do
    [
      throttle_time_ms: :int32,
      resources:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         resource_type: :int8,
         resource_name: :string}
    ]
  end

  def response_schema(:alter_replica_log_dirs, 0) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, topic: :string, partitions: {:array, partition: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:alter_replica_log_dirs, 1) do
    [
      throttle_time_ms: :int32,
      topics:
        {:array, topic: :string, partitions: {:array, partition: :int32, error_code: :int16}}
    ]
  end

  def response_schema(:describe_log_dirs, 0) do
    [
      throttle_time_ms: :int32,
      log_dirs:
        {:array,
         error_code: :int16,
         log_dir: :string,
         topics:
           {:array,
            topic: :string,
            partitions:
              {:array, partition: :int32, size: :int64, offset_lag: :int64, is_future: :boolean}}}
    ]
  end

  def response_schema(:describe_log_dirs, 1) do
    [
      throttle_time_ms: :int32,
      log_dirs:
        {:array,
         error_code: :int16,
         log_dir: :string,
         topics:
           {:array,
            topic: :string,
            partitions:
              {:array, partition: :int32, size: :int64, offset_lag: :int64, is_future: :boolean}}}
    ]
  end

  def response_schema(:sasl_authenticate, 0) do
    [error_code: :int16, error_message: :nullable_string, auth_bytes: :bytes]
  end

  def response_schema(:sasl_authenticate, 1) do
    [
      error_code: :int16,
      error_message: :nullable_string,
      auth_bytes: :bytes,
      session_lifetime_ms: :int64
    ]
  end

  def response_schema(:create_partitions, 0) do
    [
      throttle_time_ms: :int32,
      topic_errors: {:array, topic: :string, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:create_partitions, 1) do
    [
      throttle_time_ms: :int32,
      topic_errors: {:array, topic: :string, error_code: :int16, error_message: :nullable_string}
    ]
  end

  def response_schema(:create_delegation_token, 0) do
    [
      error_code: :int16,
      principal_type: :string,
      principal_name: :string,
      issue_timestamp_ms: :int64,
      expiry_timestamp_ms: :int64,
      max_timestamp_ms: :int64,
      token_id: :string,
      hmac: :bytes,
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:create_delegation_token, 1) do
    [
      error_code: :int16,
      principal_type: :string,
      principal_name: :string,
      issue_timestamp_ms: :int64,
      expiry_timestamp_ms: :int64,
      max_timestamp_ms: :int64,
      token_id: :string,
      hmac: :bytes,
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:create_delegation_token, 2) do
    [
      error_code: :int16,
      principal_type: :compact_string,
      principal_name: :compact_string,
      issue_timestamp_ms: :int64,
      expiry_timestamp_ms: :int64,
      max_timestamp_ms: :int64,
      token_id: :compact_string,
      hmac: :compact_bytes,
      throttle_time_ms: :int32,
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:renew_delegation_token, 0) do
    [error_code: :int16, expiry_timestamp_ms: :int64, throttle_time_ms: :int32]
  end

  def response_schema(:renew_delegation_token, 1) do
    [error_code: :int16, expiry_timestamp_ms: :int64, throttle_time_ms: :int32]
  end

  def response_schema(:expire_delegation_token, 0) do
    [error_code: :int16, expiry_timestamp_ms: :int64, throttle_time_ms: :int32]
  end

  def response_schema(:expire_delegation_token, 1) do
    [error_code: :int16, expiry_timestamp_ms: :int64, throttle_time_ms: :int32]
  end

  def response_schema(:describe_delegation_token, 0) do
    [
      error_code: :int16,
      tokens:
        {:array,
         principal_type: :string,
         principal_name: :string,
         issue_timestamp: :int64,
         expiry_timestamp: :int64,
         max_timestamp: :int64,
         token_id: :string,
         hmac: :bytes,
         renewers: {:array, principal_type: :string, principal_name: :string}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:describe_delegation_token, 1) do
    [
      error_code: :int16,
      tokens:
        {:array,
         principal_type: :string,
         principal_name: :string,
         issue_timestamp: :int64,
         expiry_timestamp: :int64,
         max_timestamp: :int64,
         token_id: :string,
         hmac: :bytes,
         renewers: {:array, principal_type: :string, principal_name: :string}},
      throttle_time_ms: :int32
    ]
  end

  def response_schema(:delete_groups, 0) do
    [throttle_time_ms: :int32, results: {:array, group_id: :string, error_code: :int16}]
  end

  def response_schema(:delete_groups, 1) do
    [throttle_time_ms: :int32, results: {:array, group_id: :string, error_code: :int16}]
  end

  def response_schema(:delete_groups, 2) do
    [
      throttle_time_ms: :int32,
      results:
        {:compact_array,
         group_id: :compact_string, error_code: :int16, tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:elect_leaders, 0) do
    [
      throttle_time_ms: :int32,
      replica_election_results:
        {:array,
         topic: :string,
         partition_result:
           {:array, partition_id: :int32, error_code: :int16, error_message: :nullable_string}}
    ]
  end

  def response_schema(:elect_leaders, 1) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      replica_election_results:
        {:array,
         topic: :string,
         partition_result:
           {:array, partition_id: :int32, error_code: :int16, error_message: :nullable_string}}
    ]
  end

  def response_schema(:elect_leaders, 2) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      replica_election_results:
        {:compact_array,
         topic: :compact_string,
         partition_result:
           {:compact_array,
            partition_id: :int32,
            error_code: :int16,
            error_message: :compact_nullable_string,
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:incremental_alter_configs, 0) do
    [
      throttle_time_ms: :int32,
      responses:
        {:array,
         error_code: :int16,
         error_message: :nullable_string,
         resource_type: :int8,
         resource_name: :string}
    ]
  end

  def response_schema(:incremental_alter_configs, 1) do
    [
      throttle_time_ms: :int32,
      responses:
        {:compact_array,
         error_code: :int16,
         error_message: :compact_nullable_string,
         resource_type: :int8,
         resource_name: :compact_string,
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:alter_partition_reassignments, 0) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :compact_nullable_string,
      responses:
        {:compact_array,
         name: :compact_string,
         partitions:
           {:compact_array,
            partition_index: :int32,
            error_code: :int16,
            error_message: :compact_nullable_string,
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:list_partition_reassignments, 0) do
    [
      throttle_time_ms: :int32,
      error_code: :int16,
      error_message: :compact_nullable_string,
      topics:
        {:compact_array,
         name: :compact_string,
         partitions:
           {:compact_array,
            partition_index: :int32,
            replicas: {:compact_array, :int32},
            adding_replicas: {:compact_array, :int32},
            removing_replicas: {:compact_array, :int32},
            tagged_fields: :tagged_fields},
         tagged_fields: :tagged_fields},
      tagged_fields: :tagged_fields
    ]
  end

  def response_schema(:offset_delete, 0) do
    [
      error_code: :int16,
      throttle_time_ms: :int32,
      topics:
        {:array, name: :string, partitions: {:array, partition_index: :int32, error_code: :int16}}
    ]
  end

  def min_known_error_code do
    -1
  end

  def max_known_error_code do
    71
  end

  def error_code_to_error(-1) do
    :unknown_server_error
  end

  def error_code_to_error(0) do
    :no_error
  end

  def error_code_to_error(1) do
    :offset_out_of_range
  end

  def error_code_to_error(2) do
    :corrupt_message
  end

  def error_code_to_error(3) do
    :unknown_topic_or_partition
  end

  def error_code_to_error(4) do
    :invalid_fetch_size
  end

  def error_code_to_error(5) do
    :leader_not_available
  end

  def error_code_to_error(6) do
    :not_leader_for_partition
  end

  def error_code_to_error(7) do
    :request_timed_out
  end

  def error_code_to_error(8) do
    :broker_not_available
  end

  def error_code_to_error(9) do
    :replica_not_available
  end

  def error_code_to_error(10) do
    :message_too_large
  end

  def error_code_to_error(11) do
    :stale_controller_epoch
  end

  def error_code_to_error(12) do
    :offset_metadata_too_large
  end

  def error_code_to_error(13) do
    :network_exception
  end

  def error_code_to_error(14) do
    :coordinator_load_in_progress
  end

  def error_code_to_error(15) do
    :coordinator_not_available
  end

  def error_code_to_error(16) do
    :not_coordinator
  end

  def error_code_to_error(17) do
    :invalid_topic_exception
  end

  def error_code_to_error(18) do
    :record_list_too_large
  end

  def error_code_to_error(19) do
    :not_enough_replicas
  end

  def error_code_to_error(20) do
    :not_enough_replicas_after_append
  end

  def error_code_to_error(21) do
    :invalid_required_acks
  end

  def error_code_to_error(22) do
    :illegal_generation
  end

  def error_code_to_error(23) do
    :inconsistent_group_protocol
  end

  def error_code_to_error(24) do
    :invalid_group_id
  end

  def error_code_to_error(25) do
    :unknown_member_id
  end

  def error_code_to_error(26) do
    :invalid_session_timeout
  end

  def error_code_to_error(27) do
    :rebalance_in_progress
  end

  def error_code_to_error(28) do
    :invalid_commit_offset_size
  end

  def error_code_to_error(29) do
    :topic_authorization_failed
  end

  def error_code_to_error(30) do
    :group_authorization_failed
  end

  def error_code_to_error(31) do
    :cluster_authorization_failed
  end

  def error_code_to_error(32) do
    :invalid_timestamp
  end

  def error_code_to_error(33) do
    :unsupported_sasl_mechanism
  end

  def error_code_to_error(34) do
    :illegal_sasl_state
  end

  def error_code_to_error(35) do
    :unsupported_version
  end

  def error_code_to_error(36) do
    :topic_already_exists
  end

  def error_code_to_error(37) do
    :invalid_partitions
  end

  def error_code_to_error(38) do
    :invalid_replication_factor
  end

  def error_code_to_error(39) do
    :invalid_replica_assignment
  end

  def error_code_to_error(40) do
    :invalid_config
  end

  def error_code_to_error(41) do
    :not_controller
  end

  def error_code_to_error(42) do
    :invalid_request
  end

  def error_code_to_error(43) do
    :unsupported_for_message_format
  end

  def error_code_to_error(44) do
    :policy_violation
  end

  def error_code_to_error(45) do
    :out_of_order_sequence_number
  end

  def error_code_to_error(46) do
    :duplicate_sequence_number
  end

  def error_code_to_error(47) do
    :invalid_producer_epoch
  end

  def error_code_to_error(48) do
    :invalid_txn_state
  end

  def error_code_to_error(49) do
    :invalid_producer_id_mapping
  end

  def error_code_to_error(50) do
    :invalid_transaction_timeout
  end

  def error_code_to_error(51) do
    :concurrent_transactions
  end

  def error_code_to_error(52) do
    :transaction_coordinator_fenced
  end

  def error_code_to_error(53) do
    :transactional_id_authorization_failed
  end

  def error_code_to_error(54) do
    :security_disabled
  end

  def error_code_to_error(55) do
    :operation_not_attempted
  end

  def error_code_to_error(56) do
    :kafka_storage_error
  end

  def error_code_to_error(57) do
    :log_dir_not_found
  end

  def error_code_to_error(58) do
    :sasl_authentication_failed
  end

  def error_code_to_error(59) do
    :unknown_producer_id
  end

  def error_code_to_error(60) do
    :reassignment_in_progress
  end

  def error_code_to_error(61) do
    :delegation_token_auth_disabled
  end

  def error_code_to_error(62) do
    :delegation_token_not_found
  end

  def error_code_to_error(63) do
    :delegation_token_owner_mismatch
  end

  def error_code_to_error(64) do
    :delegation_token_request_not_allowed
  end

  def error_code_to_error(65) do
    :delegation_token_authorization_failed
  end

  def error_code_to_error(66) do
    :delegation_token_expired
  end

  def error_code_to_error(67) do
    :invalid_principal_type
  end

  def error_code_to_error(68) do
    :non_empty_group
  end

  def error_code_to_error(69) do
    :group_id_not_found
  end

  def error_code_to_error(70) do
    :fetch_session_id_not_found
  end

  def error_code_to_error(71) do
    :invalid_fetch_session_epoch
  end
end