# Code generated by protox. Don't edit.
# credo:disable-for-this-file
defmodule PgQuery.TableFunc do
  @moduledoc false
  if function_exported?(Protox, :check_generator_version, 1) do
    Protox.check_generator_version(1)
  else
    raise "This code was generated with protox 2 but the runtime is using an older version of protox."
  end

  @type t :: %__MODULE__{
          location: integer(),
          ordinalitycol: integer(),
          plan: PgQuery.Node.t() | nil,
          notnulls: [non_neg_integer()],
          passingvalexprs: [PgQuery.Node.t()],
          colvalexprs: [PgQuery.Node.t()],
          coldefexprs: [PgQuery.Node.t()],
          colexprs: [PgQuery.Node.t()],
          colcollations: [PgQuery.Node.t()],
          coltypmods: [PgQuery.Node.t()],
          coltypes: [PgQuery.Node.t()],
          colnames: [PgQuery.Node.t()],
          rowexpr: PgQuery.Node.t() | nil,
          docexpr: PgQuery.Node.t() | nil,
          ns_names: [PgQuery.Node.t()],
          ns_uris: [PgQuery.Node.t()],
          functype: atom(),
          __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}]
        }
  defstruct location: 0,
            ordinalitycol: 0,
            plan: nil,
            notnulls: [],
            passingvalexprs: [],
            colvalexprs: [],
            coldefexprs: [],
            colexprs: [],
            colcollations: [],
            coltypmods: [],
            coltypes: [],
            colnames: [],
            rowexpr: nil,
            docexpr: nil,
            ns_names: [],
            ns_uris: [],
            functype: :TABLE_FUNC_TYPE_UNDEFINED,
            __uf__: []

  (
    (
      @spec encode(t()) :: {:ok, iodata(), non_neg_integer()} | {:error, any()}
      def encode(msg) do
        msg |> encode!() |> Tuple.insert_at(0, :ok)
      rescue
        e in [Protox.EncodingError, Protox.RequiredFieldsError] -> {:error, e}
      end

      @spec encode!(t()) :: {iodata(), non_neg_integer()} | no_return()
      def encode!(msg) do
        {_acc = [], _acc_size = 0}
        |> encode_location(msg)
        |> encode_ordinalitycol(msg)
        |> encode_plan(msg)
        |> encode_notnulls(msg)
        |> encode_passingvalexprs(msg)
        |> encode_colvalexprs(msg)
        |> encode_coldefexprs(msg)
        |> encode_colexprs(msg)
        |> encode_colcollations(msg)
        |> encode_coltypmods(msg)
        |> encode_coltypes(msg)
        |> encode_colnames(msg)
        |> encode_rowexpr(msg)
        |> encode_docexpr(msg)
        |> encode_ns_names(msg)
        |> encode_ns_uris(msg)
        |> encode_functype(msg)
        |> encode_unknown_fields(msg)
      end
    )

    defp encode_location({acc, acc_size}, msg) do
      if msg.location == 0 do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_int32(msg.location)
        {["\x88\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:location, "invalid field value"), __STACKTRACE__
    end

    defp encode_ordinalitycol({acc, acc_size}, msg) do
      if msg.ordinalitycol == 0 do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_int32(msg.ordinalitycol)
        {["\x80\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:ordinalitycol, "invalid field value"), __STACKTRACE__
    end

    defp encode_plan({acc, acc_size}, msg) do
      if msg.plan == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.plan)
        {["z", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:plan, "invalid field value"), __STACKTRACE__
    end

    defp encode_notnulls({acc, acc_size}, msg) do
      case msg.notnulls do
        [] ->
          {acc, acc_size}

        values ->
          {packed_bytes, packed_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_uint64(value)
                  {[value_bytes | local_acc], local_acc_size + value_bytes_size}
                end)

              {value_size_bytes, value_size_size} = Protox.Varint.encode(value_size)
              {[value_size_bytes, Enum.reverse(value_bytes)], value_size + value_size_size}
            )

          {["r", packed_bytes | acc], acc_size + 1 + packed_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:notnulls, "invalid field value"), __STACKTRACE__
    end

    defp encode_passingvalexprs({acc, acc_size}, msg) do
      case msg.passingvalexprs do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "j" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:passingvalexprs, "invalid field value"), __STACKTRACE__
    end

    defp encode_colvalexprs({acc, acc_size}, msg) do
      case msg.colvalexprs do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "b" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:colvalexprs, "invalid field value"), __STACKTRACE__
    end

    defp encode_coldefexprs({acc, acc_size}, msg) do
      case msg.coldefexprs do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "Z" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:coldefexprs, "invalid field value"), __STACKTRACE__
    end

    defp encode_colexprs({acc, acc_size}, msg) do
      case msg.colexprs do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "R" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:colexprs, "invalid field value"), __STACKTRACE__
    end

    defp encode_colcollations({acc, acc_size}, msg) do
      case msg.colcollations do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "J" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:colcollations, "invalid field value"), __STACKTRACE__
    end

    defp encode_coltypmods({acc, acc_size}, msg) do
      case msg.coltypmods do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "B" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:coltypmods, "invalid field value"), __STACKTRACE__
    end

    defp encode_coltypes({acc, acc_size}, msg) do
      case msg.coltypes do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, ":" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:coltypes, "invalid field value"), __STACKTRACE__
    end

    defp encode_colnames({acc, acc_size}, msg) do
      case msg.colnames do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "2" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:colnames, "invalid field value"), __STACKTRACE__
    end

    defp encode_rowexpr({acc, acc_size}, msg) do
      if msg.rowexpr == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.rowexpr)
        {["*", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:rowexpr, "invalid field value"), __STACKTRACE__
    end

    defp encode_docexpr({acc, acc_size}, msg) do
      if msg.docexpr == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.docexpr)
        {["\"", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:docexpr, "invalid field value"), __STACKTRACE__
    end

    defp encode_ns_names({acc, acc_size}, msg) do
      case msg.ns_names do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\x1A" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:ns_names, "invalid field value"), __STACKTRACE__
    end

    defp encode_ns_uris({acc, acc_size}, msg) do
      case msg.ns_uris do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\x12" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:ns_uris, "invalid field value"), __STACKTRACE__
    end

    defp encode_functype({acc, acc_size}, msg) do
      if msg.functype == :TABLE_FUNC_TYPE_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.functype |> PgQuery.TableFuncType.encode() |> Protox.Encode.encode_enum()

        {["\b", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:functype, "invalid field value"), __STACKTRACE__
    end

    defp encode_unknown_fields({acc, acc_size}, msg) do
      Enum.reduce(msg.__uf__, {acc, acc_size}, fn {tag, wire_type, bytes}, {acc, acc_size} ->
        case wire_type do
          0 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :int32)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}

          1 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :double)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}

          2 ->
            {len_bytes, len_size} = bytes |> byte_size() |> Protox.Varint.encode()
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :packed)

            {[acc, <<key_bytes::binary, len_bytes::binary, bytes::binary>>],
             acc_size + key_size + len_size + byte_size(bytes)}

          5 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :float)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}
        end
      end)
    end
  )

  (
    (
      @spec decode(binary()) :: {:ok, t()} | {:error, any()}
      def decode(bytes) do
        {:ok, decode!(bytes)}
      rescue
        e in [Protox.DecodingError, Protox.IllegalTagError, Protox.RequiredFieldsError] ->
          {:error, e}
      end

      (
        @spec decode!(binary()) :: t() | no_return()
        def decode!(bytes) do
          parse_key_value(bytes, struct(PgQuery.TableFunc))
        end
      )
    )

    (
      @spec parse_key_value(binary(), struct()) :: struct()
      defp parse_key_value(<<>>, msg) do
        msg
      end

      defp parse_key_value(bytes, msg) do
        {field, rest} =
          case bytes do
            <<_::5, 3::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 3")

            <<_::5, 4::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 4")

            <<_::5, 6::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 6")

            <<_::5, 7::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 7")

            <<0::5, _::3, _rest::binary>> ->
              raise %Protox.IllegalTagError{}

            <<17::5, _wire_type::3, "\x01", bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_int32(bytes)
              {[location: value], rest}

            <<16::5, _wire_type::3, "\x01", bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_int32(bytes)
              {[ordinalitycol: value], rest}

            <<15::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[plan: Protox.MergeMessage.merge(msg.plan, PgQuery.Node.decode!(delimited))], rest}

            <<"r", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[notnulls: msg.notnulls ++ Protox.Decode.parse_repeated_uint64([], delimited)],
               rest}

            <<14::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_uint64(bytes)
              {[notnulls: msg.notnulls ++ [value]], rest}

            <<13::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[passingvalexprs: msg.passingvalexprs ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<12::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[colvalexprs: msg.colvalexprs ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<11::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[coldefexprs: msg.coldefexprs ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<10::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[colexprs: msg.colexprs ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<9::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[colcollations: msg.colcollations ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<8::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[coltypmods: msg.coltypmods ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<7::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[coltypes: msg.coltypes ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<6::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[colnames: msg.colnames ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<5::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[rowexpr: Protox.MergeMessage.merge(msg.rowexpr, PgQuery.Node.decode!(delimited))],
               rest}

            <<4::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[docexpr: Protox.MergeMessage.merge(msg.docexpr, PgQuery.Node.decode!(delimited))],
               rest}

            <<3::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[ns_names: msg.ns_names ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<2::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[ns_uris: msg.ns_uris ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<1::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.TableFuncType)
              {[functype: value], rest}

            <<bytes::binary>> ->
              {tag, wire_type, rest} = Protox.Decode.parse_key(bytes)
              {value, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
              {[__uf__: msg.__uf__ ++ [value]], rest}
          end

        msg_updated = struct(msg, field)
        parse_key_value(rest, msg_updated)
      end
    )
  )

  (
    @spec unknown_fields(struct()) :: [{non_neg_integer(), Protox.Types.tag(), binary()}]
    def unknown_fields(msg) do
      msg.__uf__
    end

    @spec unknown_fields_name() :: :__uf__
    def unknown_fields_name() do
      :__uf__
    end

    @spec clear_unknown_fields(struct) :: struct
    def clear_unknown_fields(msg) do
      struct!(msg, __uf__: [])
    end
  )

  (
    @spec default(atom()) ::
            {:ok, boolean() | integer() | String.t() | float()}
            | {:error, :no_such_field | :no_default_value}
    def default(:location) do
      {:ok, 0}
    end

    def default(:ordinalitycol) do
      {:ok, 0}
    end

    def default(:plan) do
      {:ok, nil}
    end

    def default(:notnulls) do
      {:error, :no_default_value}
    end

    def default(:passingvalexprs) do
      {:error, :no_default_value}
    end

    def default(:colvalexprs) do
      {:error, :no_default_value}
    end

    def default(:coldefexprs) do
      {:error, :no_default_value}
    end

    def default(:colexprs) do
      {:error, :no_default_value}
    end

    def default(:colcollations) do
      {:error, :no_default_value}
    end

    def default(:coltypmods) do
      {:error, :no_default_value}
    end

    def default(:coltypes) do
      {:error, :no_default_value}
    end

    def default(:colnames) do
      {:error, :no_default_value}
    end

    def default(:rowexpr) do
      {:ok, nil}
    end

    def default(:docexpr) do
      {:ok, nil}
    end

    def default(:ns_names) do
      {:error, :no_default_value}
    end

    def default(:ns_uris) do
      {:error, :no_default_value}
    end

    def default(:functype) do
      {:ok, :TABLE_FUNC_TYPE_UNDEFINED}
    end

    def default(_) do
      {:error, :no_such_field}
    end
  )

  @spec schema() :: Protox.MessageSchema.t()
  def schema() do
    %{
      __struct__: Protox.MessageSchema,
      fields: %{
        colcollations: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :colcollations,
          tag: 9,
          type: {:message, PgQuery.Node}
        },
        coldefexprs: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :coldefexprs,
          tag: 11,
          type: {:message, PgQuery.Node}
        },
        colexprs: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :colexprs,
          tag: 10,
          type: {:message, PgQuery.Node}
        },
        colnames: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :colnames,
          tag: 6,
          type: {:message, PgQuery.Node}
        },
        coltypes: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :coltypes,
          tag: 7,
          type: {:message, PgQuery.Node}
        },
        coltypmods: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :coltypmods,
          tag: 8,
          type: {:message, PgQuery.Node}
        },
        colvalexprs: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :colvalexprs,
          tag: 12,
          type: {:message, PgQuery.Node}
        },
        docexpr: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :docexpr,
          tag: 4,
          type: {:message, PgQuery.Node}
        },
        functype: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :TABLE_FUNC_TYPE_UNDEFINED},
          label: :optional,
          name: :functype,
          tag: 1,
          type: {:enum, PgQuery.TableFuncType}
        },
        location: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :location,
          tag: 17,
          type: :int32
        },
        notnulls: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :packed,
          label: :repeated,
          name: :notnulls,
          tag: 14,
          type: :uint64
        },
        ns_names: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :ns_names,
          tag: 3,
          type: {:message, PgQuery.Node}
        },
        ns_uris: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :ns_uris,
          tag: 2,
          type: {:message, PgQuery.Node}
        },
        ordinalitycol: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :ordinalitycol,
          tag: 16,
          type: :int32
        },
        passingvalexprs: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :passingvalexprs,
          tag: 13,
          type: {:message, PgQuery.Node}
        },
        plan: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :plan,
          tag: 15,
          type: {:message, PgQuery.Node}
        },
        rowexpr: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :rowexpr,
          tag: 5,
          type: {:message, PgQuery.Node}
        }
      },
      file_options: nil,
      name: PgQuery.TableFunc,
      syntax: :proto3
    }
  end
end