protostar 0.1.0.beta1

data/sig/protostar/google/protobuf/duration_pb.rbs

@@ -0,0 +1,82 @@
+# Generated by protostar from google/protobuf/duration.proto. Do not edit.
+
+module Protostar
+  module Google
+    module Protobuf
+      # A Duration represents a signed, fixed-length span of time represented
+      # as a count of seconds and fractions of seconds at nanosecond
+      # resolution. It is independent of any calendar and concepts like "day"
+      # or "month". It is related to Timestamp in that the difference between
+      # two Timestamp values is a Duration and it can be added or subtracted
+      # from a Timestamp. Range is approximately +-10,000 years.
+      # # Examples
+      # Example 1: Compute Duration from two Timestamps in pseudo code.
+      #     Timestamp start = ...;
+      #     Timestamp end = ...;
+      #     Duration duration = ...;
+      #     duration.seconds = end.seconds - start.seconds;
+      #     duration.nanos = end.nanos - start.nanos;
+      #     if (duration.seconds < 0 && duration.nanos > 0) {
+      #       duration.seconds += 1;
+      #       duration.nanos -= 1000000000;
+      #     } else if (duration.seconds > 0 && duration.nanos < 0) {
+      #       duration.seconds -= 1;
+      #       duration.nanos += 1000000000;
+      #     }
+      # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+      #     Timestamp start = ...;
+      #     Duration duration = ...;
+      #     Timestamp end = ...;
+      #     end.seconds = start.seconds + duration.seconds;
+      #     end.nanos = start.nanos + duration.nanos;
+      #     if (end.nanos < 0) {
+      #       end.seconds -= 1;
+      #       end.nanos += 1000000000;
+      #     } else if (end.nanos >= 1000000000) {
+      #       end.seconds += 1;
+      #       end.nanos -= 1000000000;
+      #     }
+      # Example 3: Compute Duration from datetime.timedelta in Python.
+      #     td = datetime.timedelta(days=3, minutes=10)
+      #     duration = Duration()
+      #     duration.FromTimedelta(td)
+      # # JSON Mapping
+      # In JSON format, the Duration type is encoded as a string rather than an
+      # object, where the string ends in the suffix "s" (indicating seconds) and
+      # is preceded by the number of seconds, with nanoseconds expressed as
+      # fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+      # encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+      # be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+      # microsecond should be expressed in JSON format as "3.000001s".
+      class Duration < ::Protostar::Message
+        include ::Protostar::WellKnown::Duration
+        extend ::Protostar::WellKnown::Duration::ClassMethods
+
+        type init_map = {
+          ?seconds: ::Integer?,
+          ?nanos: ::Integer?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?seconds: ::Integer?,
+          ?nanos: ::Integer?
+        ) -> void
+
+        # Signed seconds of the span of time. Must be from -315,576,000,000
+        # to +315,576,000,000 inclusive. Note: these bounds are computed from:
+        # 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        attr_reader seconds(): ::Integer
+        attr_writer seconds(): ::Integer?
+
+        # Signed fractions of a second at nanosecond resolution of the span
+        # of time. Durations less than one second are represented with a 0
+        # `seconds` field and a positive or negative `nanos` field. For durations
+        # of one second or more, a non-zero value for the `nanos` field must be
+        # of the same sign as the `seconds` field. Must be from -999,999,999
+        # to +999,999,999 inclusive.
+        attr_reader nanos(): ::Integer
+        attr_writer nanos(): ::Integer?
+      end
+    end
+  end
+end

data/sig/protostar/google/protobuf/empty_pb.rbs

@@ -0,0 +1,18 @@
+# Generated by protostar from google/protobuf/empty.proto. Do not edit.
+
+module Protostar
+  module Google
+    module Protobuf
+      # A generic empty message that you can re-use to avoid defining duplicated
+      # empty messages in your APIs. A typical example is to use it as the request
+      # or the response type of an API method. For instance:
+      #     service Foo {
+      #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+      #     }
+      class Empty < ::Protostar::Message
+        type init_map = ::Hash[::Symbol | ::String, untyped]
+        def initialize: (?init_map? fields, **untyped) -> void
+      end
+    end
+  end
+end

data/sig/protostar/google/protobuf/field_mask_pb.rbs

@@ -0,0 +1,170 @@
+# Generated by protostar from google/protobuf/field_mask.proto. Do not edit.
+
+module Protostar
+  module Google
+    module Protobuf
+      # `FieldMask` represents a set of symbolic field paths, for example:
+      #     paths: "f.a"
+      #     paths: "f.b.d"
+      # Here `f` represents a field in some root message, `a` and `b`
+      # fields in the message found in `f`, and `d` a field found in the
+      # message in `f.b`.
+      # Field masks are used to specify a subset of fields that should be
+      # returned by a get operation or modified by an update operation.
+      # Field masks also have a custom JSON encoding (see below).
+      # # Field Masks in Projections
+      # When used in the context of a projection, a response message or
+      # sub-message is filtered by the API to only contain those fields as
+      # specified in the mask. For example, if the mask in the previous
+      # example is applied to a response message as follows:
+      #     f {
+      #       a : 22
+      #       b {
+      #         d : 1
+      #         x : 2
+      #       }
+      #       y : 13
+      #     }
+      #     z: 8
+      # The result will not contain specific values for fields x,y and z
+      # (their value will be set to the default, and omitted in proto text
+      # output):
+      #     f {
+      #       a : 22
+      #       b {
+      #         d : 1
+      #       }
+      #     }
+      # A repeated field is not allowed except at the last position of a
+      # paths string.
+      # If a FieldMask object is not present in a get operation, the
+      # operation applies to all fields (as if a FieldMask of all fields
+      # had been specified).
+      # Note that a field mask does not necessarily apply to the
+      # top-level response message. In case of a REST get operation, the
+      # field mask applies directly to the response, but in case of a REST
+      # list operation, the mask instead applies to each individual message
+      # in the returned resource list. In case of a REST custom method,
+      # other definitions may be used. Where the mask applies will be
+      # clearly documented together with its declaration in the API.  In
+      # any case, the effect on the returned resource/resources is required
+      # behavior for APIs.
+      # # Field Masks in Update Operations
+      # A field mask in update operations specifies which fields of the
+      # targeted resource are going to be updated. The API is required
+      # to only change the values of the fields as specified in the mask
+      # and leave the others untouched. If a resource is passed in to
+      # describe the updated values, the API ignores the values of all
+      # fields not covered by the mask.
+      # If a repeated field is specified for an update operation, new values will
+      # be appended to the existing repeated field in the target resource. Note that
+      # a repeated field is only allowed in the last position of a `paths` string.
+      # If a sub-message is specified in the last position of the field mask for an
+      # update operation, then new value will be merged into the existing sub-message
+      # in the target resource.
+      # For example, given the target message:
+      #     f {
+      #       b {
+      #         d: 1
+      #         x: 2
+      #       }
+      #       c: [1]
+      #     }
+      # And an update message:
+      #     f {
+      #       b {
+      #         d: 10
+      #       }
+      #       c: [2]
+      #     }
+      # then if the field mask is:
+      #  paths: ["f.b", "f.c"]
+      # then the result will be:
+      #     f {
+      #       b {
+      #         d: 10
+      #         x: 2
+      #       }
+      #       c: [1, 2]
+      #     }
+      # An implementation may provide options to override this default behavior for
+      # repeated and message fields.
+      # Note that libraries which implement FieldMask resolution have various
+      # different behaviors in the face of empty masks or the special "*" mask.
+      # When implementing a service you should confirm these cases have the
+      # appropriate behavior in the underlying FieldMask library that you desire,
+      # and you may need to special case those cases in your application code if
+      # the underlying field mask library behavior differs from your intended
+      # service semantics.
+      # Update methods implementing https://google.aip.dev/134
+      # - MUST support the special value * meaning "full replace"
+      # - MUST treat an omitted field mask as "replace fields which are present".
+      # Other methods implementing https://google.aip.dev/157
+      # - SHOULD support the special value "*" to mean "get all".
+      # - MUST treat an omitted field mask to mean "get all", unless otherwise
+      # documented.
+      # ## Considerations for HTTP REST
+      # The HTTP kind of an update operation which uses a field mask must
+      # be set to PATCH instead of PUT in order to satisfy HTTP semantics
+      # (PUT must only be used for full updates).
+      # # JSON Encoding of Field Masks
+      # In JSON, a field mask is encoded as a single string where paths are
+      # separated by a comma. Fields name in each path are converted
+      # to/from lower-camel naming conventions.
+      # As an example, consider the following message declarations:
+      #     message Profile {
+      #       User user = 1;
+      #       Photo photo = 2;
+      #     }
+      #     message User {
+      #       string display_name = 1;
+      #       string address = 2;
+      #     }
+      # In proto a field mask for `Profile` may look as such:
+      #     mask {
+      #       paths: "user.display_name"
+      #       paths: "photo"
+      #     }
+      # In JSON, the same mask is represented as below:
+      #     {
+      #       mask: "user.displayName,photo"
+      #     }
+      # # Field Masks and Oneof Fields
+      # Field masks treat fields in oneofs just as regular fields. Consider the
+      # following message:
+      #     message SampleMessage {
+      #       oneof test_oneof {
+      #         string name = 4;
+      #         SubMessage sub_message = 9;
+      #       }
+      #     }
+      # The field mask can be:
+      #     mask {
+      #       paths: "name"
+      #     }
+      # Or:
+      #     mask {
+      #       paths: "sub_message"
+      #     }
+      # Note that oneof type names ("test_oneof" in this case) cannot be used in
+      # paths.
+      # ## Field Mask Verification
+      # The implementation of any API method which has a FieldMask type field in the
+      # request should verify the included field paths, and return an
+      # `INVALID_ARGUMENT` error if any path is unmappable.
+      class FieldMask < ::Protostar::Message
+        type init_map = {
+          ?paths: ::Array[::String]?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?paths: ::Array[::String]?
+        ) -> void
+
+        # The set of field mask paths.
+        attr_reader paths(): ::Array[::String]
+        attr_writer paths(): ::Array[::String]?
+      end
+    end
+  end
+end

data/sig/protostar/google/protobuf/source_context_pb.rbs

@@ -0,0 +1,24 @@
+# Generated by protostar from google/protobuf/source_context.proto. Do not edit.
+
+module Protostar
+  module Google
+    module Protobuf
+      # `SourceContext` represents information about the source of a
+      # protobuf element, like the file in which it is defined.
+      class SourceContext < ::Protostar::Message
+        type init_map = {
+          ?file_name: ::String?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?file_name: ::String?
+        ) -> void
+
+        # The path-qualified name of the .proto file that contained the associated
+        # protobuf element.  For example: `"google/protobuf/source_context.proto"`.
+        attr_reader file_name(): ::String
+        attr_writer file_name(): ::String?
+      end
+    end
+  end
+end

data/sig/protostar/google/protobuf/struct_pb.rbs

@@ -0,0 +1,135 @@
+# Generated by protostar from google/protobuf/struct.proto. Do not edit.
+
+module Protostar
+  module Google
+    module Protobuf
+      # Represents a JSON object.
+      # An unordered key-value map, intending to perfectly capture the semantics of a
+      # JSON object. This enables parsing any arbitrary JSON payload as a message
+      # field in ProtoJSON format.
+      # This follows RFC 8259 guidelines for interoperable JSON: notably this type
+      # cannot represent large Int64 values or `NaN`/`Infinity` numbers,
+      # since the JSON format generally does not support those values in its number
+      # type.
+      # If you do not intend to parse arbitrary JSON into your message, a custom
+      # typed message should be preferred instead of using this type.
+      class Struct < ::Protostar::Message
+        include ::Protostar::WellKnown::Struct
+        extend ::Protostar::WellKnown::Struct::ClassMethods
+
+        type init_map = {
+          ?fields: (::Hash[::String, ::Protostar::Google::Protobuf::Value | ::Protostar::Google::Protobuf::Value::init_map])?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?fields: (::Hash[::String, ::Protostar::Google::Protobuf::Value | ::Protostar::Google::Protobuf::Value::init_map])?
+        ) -> void
+
+        # Unordered map of dynamically typed values.
+        attr_reader fields(): ::Hash[::String, ::Protostar::Google::Protobuf::Value]
+        attr_writer fields(): (::Hash[::String, ::Protostar::Google::Protobuf::Value | ::Protostar::Google::Protobuf::Value::init_map])?
+      end
+
+      # Represents a JSON value.
+      # `Value` represents a dynamically typed value which can be either
+      # null, a number, a string, a boolean, a recursive struct value, or a
+      # list of values. A producer of value is expected to set one of these
+      # variants. Absence of any variant is an invalid state.
+      class Value < ::Protostar::Message
+        include ::Protostar::WellKnown::Value
+        extend ::Protostar::WellKnown::Value::ClassMethods
+
+        type init_map = {
+          ?null_value: (::Protostar::Google::Protobuf::NullValue::names | ::Integer)?,
+          ?number_value: (::Float | ::Integer)?,
+          ?string_value: ::String?,
+          ?bool_value: bool?,
+          ?struct_value: (::Protostar::Google::Protobuf::Struct | ::Protostar::Google::Protobuf::Struct::init_map)?,
+          ?list_value: (::Protostar::Google::Protobuf::ListValue | ::Protostar::Google::Protobuf::ListValue::init_map)?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?null_value: (::Protostar::Google::Protobuf::NullValue::names | ::Integer)?,
+          ?number_value: (::Float | ::Integer)?,
+          ?string_value: ::String?,
+          ?bool_value: bool?,
+          ?struct_value: (::Protostar::Google::Protobuf::Struct | ::Protostar::Google::Protobuf::Struct::init_map)?,
+          ?list_value: (::Protostar::Google::Protobuf::ListValue | ::Protostar::Google::Protobuf::ListValue::init_map)?
+        ) -> void
+
+        # Represents a JSON `null`.
+        attr_reader null_value(): ::Protostar::Google::Protobuf::NullValue::names | ::Integer
+        attr_writer null_value(): (::Protostar::Google::Protobuf::NullValue::names | ::Integer)?
+        def has_null_value?: () -> bool
+        def clear_null_value: () -> void
+
+        # Represents a JSON number. Must not be `NaN`, `Infinity` or
+        # `-Infinity`, since those are not supported in JSON. This also cannot
+        # represent large Int64 values, since JSON format generally does not
+        # support them in its number type.
+        attr_reader number_value(): ::Float
+        attr_writer number_value(): (::Float | ::Integer)?
+        def has_number_value?: () -> bool
+        def clear_number_value: () -> void
+
+        # Represents a JSON string.
+        attr_reader string_value(): ::String
+        attr_writer string_value(): ::String?
+        def has_string_value?: () -> bool
+        def clear_string_value: () -> void
+
+        # Represents a JSON boolean (`true` or `false` literal in JSON).
+        attr_reader bool_value(): bool
+        attr_writer bool_value(): bool?
+        def has_bool_value?: () -> bool
+        def clear_bool_value: () -> void
+
+        # Represents a JSON object.
+        attr_reader struct_value(): ::Protostar::Google::Protobuf::Struct?
+        attr_writer struct_value(): (::Protostar::Google::Protobuf::Struct | ::Protostar::Google::Protobuf::Struct::init_map)?
+        def has_struct_value?: () -> bool
+        def clear_struct_value: () -> void
+
+        # Represents a JSON array.
+        attr_reader list_value(): ::Protostar::Google::Protobuf::ListValue?
+        attr_writer list_value(): (::Protostar::Google::Protobuf::ListValue | ::Protostar::Google::Protobuf::ListValue::init_map)?
+        def has_list_value?: () -> bool
+        def clear_list_value: () -> void
+        def which_kind: () -> (:null_value | :number_value | :string_value | :bool_value | :struct_value | :list_value)?
+      end
+
+      # Represents a JSON array.
+      class ListValue < ::Protostar::Message
+        include ::Protostar::WellKnown::ListValue
+        extend ::Protostar::WellKnown::ListValue::ClassMethods
+
+        type init_map = {
+          ?values: (::Array[::Protostar::Google::Protobuf::Value | ::Protostar::Google::Protobuf::Value::init_map])?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?values: (::Array[::Protostar::Google::Protobuf::Value | ::Protostar::Google::Protobuf::Value::init_map])?
+        ) -> void
+
+        # Repeated field of dynamically typed values.
+        attr_reader values(): ::Array[::Protostar::Google::Protobuf::Value]
+        attr_writer values(): (::Array[::Protostar::Google::Protobuf::Value | ::Protostar::Google::Protobuf::Value::init_map])?
+      end
+
+      # Represents a JSON `null`.
+      # `NullValue` is a sentinel, using an enum with only one value to represent
+      # the null value for the `Value` type union.
+      # A field of type `NullValue` with any value other than `0` is considered
+      # invalid. Most ProtoJSON serializers will emit a `Value` with a `null_value`
+      # set as a JSON `null` regardless of the integer value, and so will round trip
+      # to a `0` value.
+      module NullValue
+        extend ::Protostar::Enum
+
+        NULL_VALUE: 0
+
+        type names = :NULL_VALUE
+      end
+    end
+  end
+end

data/sig/protostar/google/protobuf/timestamp_pb.rbs

@@ -0,0 +1,102 @@
+# Generated by protostar from google/protobuf/timestamp.proto. Do not edit.
+
+module Protostar
+  module Google
+    module Protobuf
+      # A Timestamp represents a point in time independent of any time zone or local
+      # calendar, encoded as a count of seconds and fractions of seconds at
+      # nanosecond resolution. The count is relative to an epoch at UTC midnight on
+      # January 1, 1970, in the proleptic Gregorian calendar which extends the
+      # Gregorian calendar backwards to year one.
+      # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+      # second table is needed for interpretation, using a [24-hour linear
+      # smear](https://developers.google.com/time/smear).
+      # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+      # restricting to that range, we ensure that we can convert to and from [RFC
+      # 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+      # # Examples
+      # Example 1: Compute Timestamp from POSIX `time()`.
+      #     Timestamp timestamp;
+      #     timestamp.set_seconds(time(NULL));
+      #     timestamp.set_nanos(0);
+      # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+      #     struct timeval tv;
+      #     gettimeofday(&tv, NULL);
+      #     Timestamp timestamp;
+      #     timestamp.set_seconds(tv.tv_sec);
+      #     timestamp.set_nanos(tv.tv_usec * 1000);
+      # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+      #     FILETIME ft;
+      #     GetSystemTimeAsFileTime(&ft);
+      #     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+      #     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+      #     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+      #     Timestamp timestamp;
+      #     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+      #     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+      # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+      #     long millis = System.currentTimeMillis();
+      #     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+      #         .setNanos((int) ((millis % 1000) * 1000000)).build();
+      # Example 5: Compute Timestamp from Java `Instant.now()`.
+      #     Instant now = Instant.now();
+      #     Timestamp timestamp =
+      #         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+      #             .setNanos(now.getNano()).build();
+      # Example 6: Compute Timestamp from current time in Python.
+      #     timestamp = Timestamp()
+      #     timestamp.GetCurrentTime()
+      # # JSON Mapping
+      # In JSON format, the Timestamp type is encoded as a string in the
+      # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+      # format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+      # where {year} is always expressed using four digits while {month}, {day},
+      # {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+      # seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+      # are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+      # is required. A ProtoJSON serializer should always use UTC (as indicated by
+      # "Z") when printing the Timestamp type and a ProtoJSON parser should be
+      # able to accept both UTC and other timezones (as indicated by an offset).
+      # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+      # 01:30 UTC on January 15, 2017.
+      # In JavaScript, one can convert a Date object to this format using the
+      # standard
+      # [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+      # method. In Python, a standard `datetime.datetime` object can be converted
+      # to this format using
+      # [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+      # the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+      # the Joda Time's [`ISODateTimeFormat.dateTime()`](
+      # http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+      # ) to obtain a formatter capable of generating timestamps in this format.
+      class Timestamp < ::Protostar::Message
+        include ::Protostar::WellKnown::Timestamp
+        extend ::Protostar::WellKnown::Timestamp::ClassMethods
+
+        type init_map = {
+          ?seconds: ::Integer?,
+          ?nanos: ::Integer?
+        }
+        def initialize: (
+          ?init_map? fields,
+          ?seconds: ::Integer?,
+          ?nanos: ::Integer?
+        ) -> void
+
+        # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
+        # be between -62135596800 and 253402300799 inclusive (which corresponds to
+        # 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
+        attr_reader seconds(): ::Integer
+        attr_writer seconds(): ::Integer?
+
+        # Non-negative fractions of a second at nanosecond resolution. This field is
+        # the nanosecond portion of the duration, not an alternative to seconds.
+        # Negative second values with fractions must still have non-negative nanos
+        # values that count forward in time. Must be between 0 and 999,999,999
+        # inclusive.
+        attr_reader nanos(): ::Integer
+        attr_writer nanos(): ::Integer?
+      end
+    end
+  end
+end