protobufable 0.1.0

data/sig/generated/protobufable/alba_binding.rbs

@@ -0,0 +1,101 @@
+# Generated from lib/protobufable/alba_binding.rb with RBS::Inline
+
+module Protobufable
+  # Binds an Alba resource to the protobuf message it produces, and checks at load time that
+  # the two agree on every field.
+  #
+  # Serialization stays idiomatic — one resource per model, with Alba's association DSL — while
+  # the wire format belongs to the schema. The parity check is the point: without it a field
+  # added to the .proto has no producer and simply comes back empty, which nothing reports.
+  #
+  # @example
+  #   class WidgetResource < ApplicationResource
+  #     with_protobuf Api::Widget do
+  #       attributes :id, :name
+  #       attribute(:created_at) { |w| w.created_at.to_time }
+  #     end
+  #   end
+  #
+  #   render proto_json: Api::GetWidgetResponse.new(widget: WidgetResource.new(widget).as_protobuf)
+  #
+  # The check reads Alba's `@_attributes` and `@_traits`, which are internal to Alba, so an
+  # Alba release can break it. A spec pins the assumption against the installed version.
+  #
+  # @rbs module-self _AlbaBindingSelf
+  module AlbaBinding : _AlbaBindingSelf
+    # @param base [Class] the Alba resource class including this
+    # @return [void]
+    # : (untyped base) -> void
+    def self.included: (untyped base) -> void
+
+    # Each of these reaches the binding through `self.class`: Alba installs HelperMethods on
+    # instances too, so a bare `message_class` here would resolve to the class-level reader with
+    # `self` being the instance, whose ivar is never set.
+    #
+    # @return [Object] the bound message, built from the serialized attributes
+    # : () -> untyped
+    def as_protobuf: () -> untyped
+
+    # @return [String] the bound message encoded as binary protobuf
+    # : () -> String
+    def to_protobuf: () -> String
+
+    # Renders through the message's own encoder rather than Alba's, so the wire format is the
+    # schema's. Field names and default omission match the proto_json renderer.
+    #
+    # @return [String] the bound message as ProtoJSON
+    # : (*untyped) -> String
+    def to_json: (*untyped) -> String
+
+    # Class-level DSL, installed through Alba's own helper mechanism.
+    #
+    # @rbs module-self _AlbaBindingClass
+    module HelperMethods : _AlbaBindingClass
+      # @return [Class] the message class this resource is bound to
+      # @raise [Protobufable::Error] when the resource declared no binding
+      # : () -> Google::Protobuf::_MessageClass
+      def message_class: () -> Google::Protobuf::_MessageClass
+
+      # Binds this resource to a message and declares its attributes.
+      #
+      # Both directions are checked: an attribute the message does not declare, and a field no
+      # attribute produces, each fail here rather than at response time. The check runs when this
+      # does, so an attribute declared after it is never compared; everything belongs inside the
+      # block.
+      #
+      # @param klass [Class] the generated message class
+      # @yield the resource's attribute declarations
+      # @return [void]
+      # @raise [Protobufable::Error] when the two have drifted apart
+      # : (Google::Protobuf::_MessageClass klass) { () -> void } -> void
+      def with_protobuf: (Google::Protobuf::_MessageClass klass) { () -> void } -> void
+    end
+
+    # Registers a `:timestamp` Alba type that converts to Time.
+    #
+    # A `google.protobuf.Timestamp` field accepts a Time but refuses an
+    # ActiveSupport::TimeWithZone, which is what an ActiveRecord timestamp column hands back,
+    # so a resource serializing one needs the conversion.
+    #
+    #   Protobufable::AlbaBinding.register_timestamp_type!
+    #
+    #   attribute :created_at, :timestamp
+    #
+    # Opt-in rather than done on require: Alba's type registry is global, and a gem should not
+    # add to it behind a host's back.
+    #
+    # @return [void]
+    # : () -> void
+    def self.register_timestamp_type!: () -> void
+
+    # Every attribute a resource can produce, including the ones a trait adds.
+    #
+    # A trait is a block rather than a list, so the only way to see what it declares is to
+    # evaluate it, which is what the throwaway subclass is for.
+    #
+    # @param resource [Class] the Alba resource
+    # @return [Array<Symbol>]
+    # : (untyped resource) -> Array[Symbol]
+    def self.produced_attributes: (untyped resource) -> Array[Symbol]
+  end
+end

data/sig/generated/protobufable/bad_request.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/protobufable/bad_request.rb with RBS::Inline
+
+module Protobufable
+  # Turns protovalidate violations into a `google.rpc.BadRequest`, the form AIP-193 defines for
+  # telling a client which fields it got wrong.
+  #
+  # Hand the result to {Problem::Information}, which publishes it in the document.
+  #
+  # @example
+  #   class InvalidMessage < Errors::BadRequest
+  #     include Protobufable::Problem::Information
+  #
+  #     def initialize(violations:, **kwargs)
+  #       @violations = violations
+  #       super(**kwargs)
+  #     end
+  #
+  #     def problem_information
+  #       super + [Protobufable::BadRequest.for(@violations, message_class)]
+  #     end
+  #   end
+  #
+  # `google.rpc` descriptors are not shipped with this gem; the app that generates googleapis
+  # alongside its own protos supplies them.
+  module BadRequest
+    # The message this builds.
+    MESSAGE: String
+
+    # @param violations [Array<Protovalidate::Violation>]
+    # @param message_class [Class] the message the violations were produced from
+    # @param json_names [Boolean] whether field paths name fields as ProtoJSON spells them
+    # @return [Object] a `google.rpc.BadRequest`, one FieldViolation per violation
+    # @raise [Protobufable::Error] when googleapis has not been generated into the pool
+    # : (Array[untyped] violations, Google::Protobuf::_MessageClass message_class, ?json_names: bool) -> untyped
+    def self.for: (Array[untyped] violations, Google::Protobuf::_MessageClass message_class, ?json_names: bool) -> untyped
+  end
+end

data/sig/generated/protobufable/column_validatable.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/protobufable/column_validatable.rb with RBS::Inline
+
+module Protobufable
+  # Runs the `buf.validate` rules of every {JsonType} column before the record is saved, so a
+  # column holding a message enforces what its .proto declares wherever the record is written:
+  # application code, a seed, the console.
+  #
+  # @example
+  #   class ApplicationRecord < ActiveRecord::Base
+  #     include Protobufable::ColumnValidatable
+  #   end
+  #
+  # @rbs module-self _ColumnValidatableSelf
+  module ColumnValidatable : _ColumnValidatableSelf
+    extend ActiveSupport::Concern
+
+    # Adds one error per violation, under the attribute that holds the message.
+    #
+    # @return [void]
+    # : () -> void
+    private def validate_protobuf_message_columns: () -> void
+  end
+end

data/sig/generated/protobufable/connect/problem_rescuable.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/protobufable/connect/problem_rescuable.rb with RBS::Inline
+
+module Protobufable
+  module Connect
+    # Answers a ::Problem::Detailable raised in a Connect RPC as a Connect error rather than as
+    # application/problem+json.
+    #
+    # The code is read off the problem's status and the message is its detail, or its title when
+    # there is none. The document itself travels as a detail, so a caller dispatches on the same
+    # `type` over Connect as over REST.
+    #
+    # @example
+    #   class WidgetsController < ActionController::API
+    #     include ConnectRpcRails::Controller
+    #     include Protobufable::Connect::ProblemRescuable
+    #
+    #     connect_service "myapp.api.WidgetsService"
+    #   end
+    #
+    # Include it after ConnectRpcRails::Controller. Only a problem raised inside the controller is
+    # answered this way; one escaping before dispatch reaches the exceptions app.
+    #
+    # @rbs module-self _ProblemRescuableSelf
+    module ProblemRescuable : _ProblemRescuableSelf
+      extend ActiveSupport::Concern
+
+      include ::Problem::Rescuable
+
+      # Builds the message the document travels as. Override to build the application's own copy
+      # of the message instead.
+      #
+      # `information` carries the error's {Problem::Information} messages, packed as they are rather
+      # than re-read from the rendered document. Other extension members are dropped, because the
+      # message has no slot for them.
+      #
+      # @param problem [::Problem::Details]
+      # @param error [Exception] the error the document was built from
+      # @return [Object] a protobuf message
+      # : (::Problem::Details problem, untyped error) -> untyped
+      private def problem_message_for: (::Problem::Details problem, untyped error) -> untyped
+
+      # @param problem [::Problem::Details]
+      # @param error [Exception]
+      # @return [void]
+      # : (::Problem::Details problem, untyped error) -> void
+      private def render_problem: (::Problem::Details problem, untyped error) -> void
+    end
+  end
+end

data/sig/generated/protobufable/connect.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/protobufable/connect.rb with RBS::Inline
+
+module Protobufable
+  # The connect_rpc_rails integration: problems answered as Connect errors.
+  module Connect
+  end
+end

data/sig/generated/protobufable/field_path.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/protobufable/field_path.rb with RBS::Inline
+
+module Protobufable
+  # Renders a `buf.validate.FieldPath` in the spelling the caller sent.
+  #
+  # A field path is only useful if the client can find the field it names, and a protobuf field
+  # has two published names: `preferred_language` in the binary encoding and in ProtoJSON with
+  # `preserve_proto_fieldnames`, `preferredLanguage` in ProtoJSON without it. Which one to use
+  # is a property of the encoding in play, so each segment is resolved against the descriptor
+  # rather than interpolated from the name the violation happened to carry.
+  #
+  # @example
+  #   Protobufable::FieldPath.render(violation.field, CreateWidgetRequest, json_names: true)
+  #   #=> "widget.tags[0]"
+  module FieldPath
+    # Renders a path against the message it was produced from.
+    #
+    # @param path [Object, nil] a `buf.validate.FieldPath`
+    # @param message_class [Class] the message the path is rooted in
+    # @param json_names [Boolean] whether to publish `json_name` rather than the proto name
+    # @return [String] the path, empty for a message-level rule
+    # : (untyped path, Google::Protobuf::_MessageClass message_class, ?json_names: bool) -> String
+    def self.render: (untyped path, Google::Protobuf::_MessageClass message_class, ?json_names: bool) -> String
+
+    # @return [String] the name this segment is published under
+    # : (untyped field, untyped element, json_names: bool) -> String
+    def self.publish: (untyped field, untyped element, json_names: bool) -> String
+
+    # @return [String] the `[...]` suffix for a repeated or map element, empty otherwise
+    # : (untyped element) -> String
+    def self.subscript: (untyped element) -> String
+  end
+end

data/sig/generated/protobufable/json_type.rbs

@@ -0,0 +1,72 @@
+# Generated from lib/protobufable/json_type.rb with RBS::Inline
+
+module Protobufable
+  # An ActiveModel type storing a protobuf message in a native `json` or `jsonb` column.
+  #
+  # Encoding goes through the message's own `encode_json` and `decode_json`, so the stored
+  # document is constrained to the protobuf schema rather than to whatever a Hash happened to
+  # hold. Being a type rather than a `serialize` coder is what buys dirty tracking, casting
+  # from a Hash, and a column the adapter knows is JSON.
+  #
+  # @example A column that is never null in Ruby
+  #   class Widget < ApplicationRecord
+  #     attribute :settings, Protobufable::JsonType.new(Internal::WidgetSettings),
+  #       default: -> { Internal::WidgetSettings.new }
+  #   end
+  class JsonType < ActiveModel::Type::Value
+    # @return [Class] the generated message class this column holds
+    attr_reader message_class: Google::Protobuf::_MessageClass
+
+    # @param message_class [Class] the generated message class this column holds
+    # @param nil_as_default [Boolean] whether a null column reads back as an empty message,
+    #   for a nullable column whose Ruby value is semantically non-null
+    # @param preserve_proto_fieldnames [Boolean] whether documents are written with the
+    #   `.proto` field names (`snake_case`) rather than their lowerCamelCase JSON names
+    # @return [void]
+    # : (Google::Protobuf::_MessageClass message_class, ?nil_as_default: bool, ?preserve_proto_fieldnames: bool) -> void
+    def initialize: (Google::Protobuf::_MessageClass message_class, ?nil_as_default: bool, ?preserve_proto_fieldnames: bool) -> void
+
+    # @return [Symbol] always `:json`, so Rails and the adapter treat the column as JSON
+    # : () -> Symbol
+    def type: () -> Symbol
+
+    # Decodes a stored document into a message.
+    #
+    # Unknown fields are tolerated: during a rolling deploy a row written by a newer schema has
+    # to stay readable on a node that has not picked it up yet.
+    #
+    # @param value [String, nil] the document as the adapter hands it back
+    # @return [Object, nil] the decoded message, or nil for a null column
+    # : (String? value) -> untyped
+    def deserialize: (String? value) -> untyped
+
+    # Encodes a message for storage.
+    #
+    # Defaults are emitted so the stored shape does not depend on which fields happened to be
+    # set, which is what makes {#changed_in_place?} meaningful and spares anything reading the
+    # column in SQL from telling absent from default.
+    #
+    # @param value [Object, nil] the message to store
+    # @return [String, nil] the document to write, or nil
+    # : (untyped value) -> String?
+    def serialize: (untyped value) -> String?
+
+    # Coerces an assigned value into a message, accepting what a form, a fixture or a seed
+    # would supply as well as a message itself.
+    #
+    # @param value [Object, String, Hash, nil]
+    # @return [Object, nil] the message, or the value unchanged when it is none of those
+    # : (untyped value) -> untyped
+    def cast: (untyped value) -> untyped
+
+    # Compares decoded messages rather than encoded text: a jsonb column hands back a
+    # canonicalized document whose key order and spacing need not match what `encode_json`
+    # produced, which would otherwise read as a change on every load.
+    #
+    # @param raw_old_value [String, nil] the document as it was loaded
+    # @param new_value [Object, nil] the message currently held
+    # @return [Boolean]
+    # : (String? raw_old_value, untyped new_value) -> bool
+    def changed_in_place?: (String? raw_old_value, untyped new_value) -> bool
+  end
+end

data/sig/generated/protobufable/problem/information.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/protobufable/problem/information.rb with RBS::Inline
+
+module Protobufable
+  module Problem
+    # Publishes machine-readable data about an occurrence as protobuf messages, in an
+    # `information` extension member.
+    #
+    # RFC 9457 reserves `detail` for prose, so anything a client is meant to act on rather than
+    # read goes somewhere else. This packs each message as a `google.protobuf.Any`, which is what
+    # lets one member carry `google.rpc.BadRequest`, `ErrorInfo` and whatever else an occurrence
+    # has to say without the document declaring a slot for each.
+    #
+    # @example
+    #   class InvalidWidget < Errors::ApiError
+    #     include Protobufable::Problem::Information
+    #
+    #     def problem_information
+    #       super + [Google::Rpc::BadRequest.new(field_violations: violations)]
+    #     end
+    #   end
+    #
+    #   {"type": "...", "status": 400, "information": [
+    #     {"@type": "type.googleapis.com/google.rpc.BadRequest", "field_violations": [...]}
+    #   ]}
+    #
+    # Every hook calls `super`, so this composes with ::Problem::RetryAfter and with another mixin
+    # of your own rather than replacing what they contribute.
+    #
+    # @rbs module-self ::Problem::Detailable
+    module Information : ::Problem::Detailable
+      # The extension member the packed messages are published in.
+      MEMBER: Symbol
+
+      # Protobuf messages this occurrence publishes. Override and call `super`.
+      #
+      # @return [Array<Object>]
+      # : () -> Array[untyped]
+      def problem_information: () -> Array[untyped]
+
+      # Adds the packed messages to the document, and nothing at all when there are none: an
+      # empty member would be noise on every error that carries no detail of this kind.
+      #
+      # @return [Hash{Symbol => Object}]
+      # : () -> Hash[Symbol, untyped]
+      def problem_extensions: () -> Hash[Symbol, untyped]
+
+      # Packs one message as a `google.protobuf.Any` and renders it as ProtoJSON.
+      #
+      # Field names are preserved rather than lowerCamelCased, matching what the proto_json
+      # renderer sends, so a client reads one spelling across the whole API.
+      #
+      # @param message [Object] a protobuf message
+      # @return [Hash] the Any as ProtoJSON, carrying an `@type` alongside the message's fields
+      # : (untyped message) -> untyped
+      def self.pack: (untyped message) -> untyped
+    end
+  end
+end

data/sig/generated/protobufable/problem/retry_info.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/protobufable/problem/retry_info.rb with RBS::Inline
+
+module Protobufable
+  module Problem
+    # Publishes a retry interval as a `google.rpc.RetryInfo` as well as a Retry-After header.
+    #
+    # ::Problem::RetryAfter already sends the header and a `retry_after` member, which a generic
+    # HTTP client obeys. This adds the form a client generated from the same protos already knows
+    # how to read, so the two kinds of caller get the same answer.
+    #
+    # @example
+    #   class TooManyRequests < Errors::ApiError
+    #     include Protobufable::Problem::RetryInfo
+    #
+    #     problem_type :PROBLEM_TYPE_TOO_MANY_REQUESTS
+    #   end
+    #
+    #   raise TooManyRequests.new(retry_after: 30)
+    #
+    # `google.rpc` descriptors are not shipped with this gem: they belong to the app that
+    # generates googleapis alongside its own protos. The message class is looked up when it is
+    # first needed, and the error names what to generate if it is missing.
+    #
+    # @rbs module-self ::Problem::Detailable
+    module RetryInfo : ::Problem::Detailable
+      include ::Problem::RetryAfter
+
+      include Information
+
+      # The message this publishes.
+      MESSAGE: String
+
+      # @return [Array<Object>] the occurrence's messages, with the retry interval appended
+      # : () -> Array[untyped]
+      def problem_information: () -> Array[untyped]
+
+      # @param seconds [Integer] the wait
+      # @return [Object] a `google.rpc.RetryInfo` carrying it
+      # @raise [Protobufable::Error] when googleapis has not been generated into the pool
+      # : (Integer seconds) -> untyped
+      def self.message_for: (Integer seconds) -> untyped
+    end
+  end
+end

data/sig/generated/protobufable/problem/typeable.rbs

@@ -0,0 +1,166 @@
+# Generated from lib/protobufable/problem/typeable.rb with RBS::Inline
+
+module Protobufable
+  module Problem
+    # Derives an error's RFC 9457 type and status from a protobuf enum, whose values carry them
+    # as a custom option.
+    #
+    # This is the catalogue layer ::Problem::Detailable documents: it prepends a module to the
+    # error class's singleton that overrides `type` and `status`, and calls `super` for a class
+    # the catalogue does not cover, so a literal declaration still works.
+    #
+    # Applications whose enum is annotated with one option per property override
+    # {ClassMethods#problem_uri_annotation} and {ClassMethods#problem_status_annotation} instead.
+    #
+    # @example
+    #   module Errors
+    #     class ApiError < StandardError
+    #       include Protobufable::Problem::Typeable
+    #
+    #       def self.problem_type_enum = "myapp.api.ProblemType"
+    #       def self.problem_type_annotation = "myapp.api.problem_type"
+    #     end
+    #
+    #     class WidgetNotReady < ApiError
+    #       problem_type :PROBLEM_TYPE_WIDGET_NOT_READY
+    #     end
+    #   end
+    #
+    # The status is an annotation on the value rather than a property of the code path that
+    # raised it: two errors needing different statuses are different types. Several values may
+    # publish one identifier on purpose, where telling them apart would leak something; because
+    # ::Problem::I18nable keys titles by the published identifier, they share a title too, which is
+    # the invariant that keeps the distinction hidden.
+    #
+    # @rbs module-self ::Exception
+    # @rbs module-self ::Problem::_DetailableSelf
+    module Typeable : ::Exception, ::Problem::_DetailableSelf
+      extend ActiveSupport::Concern
+
+      include ::Problem::I18nable
+
+      # What one enum value publishes.
+      class Entry < Data
+        attr_reader uri(): untyped
+
+        attr_reader http_status(): untyped
+
+        def self.new: (untyped uri, untyped http_status) -> instance
+                    | (uri: untyped, http_status: untyped) -> instance
+
+        def self.members: () -> [ :uri, :http_status ]
+
+        def members: () -> [ :uri, :http_status ]
+      end
+
+      # Overrides ::Problem::Detailable's literal DSL for a class that declared a value, and falls
+      # through to it for one that did not.
+      #
+      # Prepended to the singleton class rather than defined in ClassMethods so it wins whichever
+      # order the concerns were mixed in. A class that spells out a literal keeps it, the rule
+      # ::Problem::I18nable already follows, so a codebase can move onto a catalogue gradually.
+      #
+      # @rbs module-self _TypeableClass
+      module Derivation : _TypeableClass
+        # The identifier the declared value publishes, which is its annotation rather than its
+        # name: several values deliberately publish the same one.
+        #
+        # @param value [String, nil] a literal declaration, which takes precedence
+        # @return [String, nil]
+        # : (?String?) -> String?
+        def type: (?String?) -> String?
+
+        # The status the declared value is returned with.
+        #
+        # @param value [Integer, nil] a literal declaration, which takes precedence
+        # @return [Integer, nil]
+        # : (?Integer?) -> Integer?
+        def status: (?Integer?) -> Integer?
+      end
+
+      # @rbs module-self _TypeableClass
+      module ClassMethods : _TypeableClass
+        # The full name of the enum this class's catalogue lives in.
+        #
+        # No default: an app's catalogue is the one thing a gem cannot guess. Override it on the
+        # base class the rest of the errors inherit from.
+        #
+        # @return [String]
+        # @raise [Protobufable::Error] when it has not been overridden
+        # : () -> String
+        def problem_type_enum: () -> String
+
+        # The full name of the extension carrying a value's uri and http_status as one message.
+        #
+        # No default either, because nothing generated from the gem's own .proto is shipped while
+        # its option number is provisional. See DESIGN.md.
+        #
+        # @return [String]
+        # @raise [Protobufable::Error] when neither this nor the split pair has been overridden
+        # : () -> String
+        def problem_type_annotation: () -> String
+
+        # The extension carrying a value's identifier, for a catalogue that spends one option
+        # number per property rather than carrying both in one message.
+        #
+        # Override this and {problem_status_annotation} together, instead of
+        # {problem_type_annotation}, when the enum is already annotated that way. An established
+        # schema does not have to be rewritten to be read from here.
+        #
+        # @return [String, nil]
+        # : () -> String?
+        def problem_uri_annotation: () -> String?
+
+        # The extension carrying a value's status, alongside {problem_uri_annotation}.
+        #
+        # @return [String, nil]
+        # : () -> String?
+        def problem_status_annotation: () -> String?
+
+        # Declares which enum value this class renders as, or reads back what was declared.
+        #
+        # An unknown or unannotated value raises here, at class definition time, so a typo fails
+        # on boot rather than on the first request that reaches the error.
+        #
+        # @param value [Symbol, nil] the enum value name
+        # @return [Symbol, nil]
+        # @raise [Protobufable::Error] when the catalogue does not cover the value
+        # : (?Symbol?) -> Symbol?
+        def problem_type: (?Symbol?) -> Symbol?
+
+        # The catalogue this class reads, built from the enum on first use.
+        #
+        # Memoized on the class that asked rather than in a table keyed by enum name: a reloaded
+        # or anonymous class then cannot read a catalogue built for a previous one.
+        #
+        # @return [Hash{Symbol => Entry}]
+        # : () -> Hash[Symbol, Entry]
+        def problem_type_catalogue: () -> Hash[Symbol, Entry]
+
+        # @return [Entry] what the declared value publishes
+        # : () -> Entry
+        def problem_type_entry: () -> Entry
+      end
+
+      # Reads every annotated value of an enum.
+      #
+      # @param enum [String] full name of the enum
+      # @param annotation [String, nil] full name of the single sub-message extension
+      # @param uri_annotation [String, nil] full name of the identifier extension
+      # @param status_annotation [String, nil] full name of the status extension
+      # @return [Hash{Symbol => Entry}] one entry per value carrying both properties
+      # @raise [Protobufable::Error] when a name does not resolve, or the split pair is half given
+      # : (enum: String, annotation: String?, uri_annotation: String?, status_annotation: String?) -> Hash[Symbol, Entry]
+      def self.build_catalogue: (enum: String, annotation: String?, uri_annotation: String?, status_annotation: String?) -> Hash[Symbol, Entry]
+
+      # @return [Proc] reads one value's options into an Entry, or nil when it carries none
+      # : (untyped pool, String? annotation, String? uri_annotation, String? status_annotation) -> ^(untyped) -> Entry?
+      def self.entry_readers: (untyped pool, String? annotation, String? uri_annotation, String? status_annotation) -> ^(untyped) -> Entry?
+
+      # @return [Google::Protobuf::FieldDescriptor]
+      # @raise [Protobufable::Error] when the extension is not in the pool
+      # : (untyped pool, String name) -> untyped
+      def self.lookup_extension!: (untyped pool, String name) -> untyped
+    end
+  end
+end

data/sig/generated/protobufable/problem.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/protobufable/problem.rb with RBS::Inline
+
+module Protobufable
+  # The problem gem integration: a catalogue backed by a protobuf enum, and protobuf messages in
+  # a problem document. Code in here names the problem gem's own constants as `::Problem`.
+  module Problem
+  end
+end

data/sig/generated/protobufable/protovalidate.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/protobufable/protovalidate.rb with RBS::Inline
+

data/sig/generated/protobufable/railtie.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/protobufable/railtie.rb with RBS::Inline
+
+module Protobufable
+  # Installs the renderers and the request body parser on boot, and classifies a broken
+  # `buf.validate` rule as a 400.
+  class Railtie < ::Rails::Railtie
+  end
+end

data/sig/generated/protobufable/renderers.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/protobufable/renderers.rb with RBS::Inline
+
+module Protobufable
+  # The media types and renderers for answering with a protobuf message.
+  #
+  # @example Binary, for a client that asked for it
+  #   render protobuf: Api::GetWidgetResponse.new(widget:)
+  #
+  # @example ProtoJSON, which is ordinary JSON a client needs to know nothing about
+  #   render proto_json: Api::GetWidgetResponse.new(widget:)
+  module Renderers
+    # The media type the binary renderer answers with.
+    CONTENT_TYPE: String
+
+    # Registers the media type and both renderers. Idempotent, so a second host installing on
+    # the same process is harmless.
+    #
+    # @return [void]
+    # : () -> void
+    def self.install!: () -> void
+  end
+end