temporalio 0.1.0 → 0.1.1

data/sig/protos/google/protobuf/duration.rbs

@@ -0,0 +1,114 @@
+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 < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (Duration) -> String
+
+      # 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_accessor seconds(): ::Integer
+
+      def 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_accessor nanos(): ::Integer
+
+      def nanos!: () -> ::Integer?
+
+      def initialize: (?seconds: ::Integer, ?nanos: ::Integer) -> void
+
+      def []: (:seconds) -> ::Integer
+            | (:nanos) -> ::Integer
+            | (::Symbol) -> untyped
+
+      def []=: (:seconds, ::Integer) -> ::Integer
+             | (:nanos, ::Integer) -> ::Integer
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> Duration
+      end
+
+      # The type of `#initialize` parameter.
+      type init = Duration | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[Duration, Duration | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, Duration, Duration | _ToProto]
+
+      type array = ::Array[Duration | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, Duration | _ToProto]
+    end
+  end
+end

data/sig/protos/google/protobuf/empty.rbs

@@ -0,0 +1,36 @@
+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 < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (Empty) -> String
+
+      def initialize: () -> void
+
+      interface _ToProto
+        def to_proto: () -> Empty
+      end
+
+      # The type of `#initialize` parameter.
+      type init = Empty | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[Empty, Empty | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, Empty, Empty | _ToProto]
+
+      type array = ::Array[Empty | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, Empty | _ToProto]
+    end
+  end
+end

data/sig/protos/google/protobuf/timestamp.rbs

@@ -0,0 +1,145 @@
+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 proto3 JSON serializer should always use UTC (as indicated by
+    #  "Z") when printing the Timestamp type and a proto3 JSON 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://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+    #  ) to obtain a formatter capable of generating timestamps in this format.
+    #
+    class Timestamp < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (Timestamp) -> String
+
+      # Represents seconds of UTC time since Unix epoch
+      #  1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+      #  9999-12-31T23:59:59Z inclusive.
+      #
+      attr_accessor seconds(): ::Integer
+
+      def seconds!: () -> ::Integer?
+
+      # Non-negative fractions of a second at nanosecond resolution. Negative
+      #  second values with fractions must still have non-negative nanos values
+      #  that count forward in time. Must be from 0 to 999,999,999
+      #  inclusive.
+      #
+      attr_accessor nanos(): ::Integer
+
+      def nanos!: () -> ::Integer?
+
+      def initialize: (?seconds: ::Integer, ?nanos: ::Integer) -> void
+
+      def []: (:seconds) -> ::Integer
+            | (:nanos) -> ::Integer
+            | (::Symbol) -> untyped
+
+      def []=: (:seconds, ::Integer) -> ::Integer
+             | (:nanos, ::Integer) -> ::Integer
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> Timestamp
+      end
+
+      # The type of `#initialize` parameter.
+      type init = Timestamp | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[Timestamp, Timestamp | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, Timestamp, Timestamp | _ToProto]
+
+      type array = ::Array[Timestamp | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, Timestamp | _ToProto]
+    end
+  end
+end

data/sig/protos/google/protobuf/wrappers.rbs

@@ -0,0 +1,358 @@
+module Google
+  module Protobuf
+    # Wrapper message for `double`.
+    #
+    #  The JSON representation for `DoubleValue` is JSON number.
+    #
+    class DoubleValue < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (DoubleValue) -> String
+
+      # The double value.
+      #
+      attr_accessor value(): ::Float
+
+      def value!: () -> ::Float?
+
+      def initialize: (?value: ::Float) -> void
+
+      def []: (:value) -> ::Float
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::Float) -> ::Float
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> DoubleValue
+      end
+
+      # The type of `#initialize` parameter.
+      type init = DoubleValue | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[DoubleValue, DoubleValue | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, DoubleValue, DoubleValue | _ToProto]
+
+      type array = ::Array[DoubleValue | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, DoubleValue | _ToProto]
+    end
+
+    # Wrapper message for `float`.
+    #
+    #  The JSON representation for `FloatValue` is JSON number.
+    #
+    class FloatValue < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (FloatValue) -> String
+
+      # The float value.
+      #
+      attr_accessor value(): ::Float
+
+      def value!: () -> ::Float?
+
+      def initialize: (?value: ::Float) -> void
+
+      def []: (:value) -> ::Float
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::Float) -> ::Float
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> FloatValue
+      end
+
+      # The type of `#initialize` parameter.
+      type init = FloatValue | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[FloatValue, FloatValue | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, FloatValue, FloatValue | _ToProto]
+
+      type array = ::Array[FloatValue | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, FloatValue | _ToProto]
+    end
+
+    # Wrapper message for `int64`.
+    #
+    #  The JSON representation for `Int64Value` is JSON string.
+    #
+    class Int64Value < ::Protobuf::Message
+      # The int64 value.
+      #
+      attr_accessor value(): ::Integer
+
+      def value!: () -> ::Integer?
+
+      def initialize: (?value: ::Integer) -> void
+
+      def []: (:value) -> ::Integer
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::Integer) -> ::Integer
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> Int64Value
+      end
+
+      # The type of `#initialize` parameter.
+      type init = Int64Value | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[Int64Value, Int64Value | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, Int64Value, Int64Value | _ToProto]
+
+      type array = ::Array[Int64Value | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, Int64Value | _ToProto]
+    end
+
+    # Wrapper message for `uint64`.
+    #
+    #  The JSON representation for `UInt64Value` is JSON string.
+    #
+    class UInt64Value < ::Protobuf::Message
+      # The uint64 value.
+      #
+      attr_accessor value(): ::Integer
+
+      def value!: () -> ::Integer?
+
+      def initialize: (?value: ::Integer) -> void
+
+      def []: (:value) -> ::Integer
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::Integer) -> ::Integer
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> UInt64Value
+      end
+
+      # The type of `#initialize` parameter.
+      type init = UInt64Value | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[UInt64Value, UInt64Value | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, UInt64Value, UInt64Value | _ToProto]
+
+      type array = ::Array[UInt64Value | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, UInt64Value | _ToProto]
+    end
+
+    # Wrapper message for `int32`.
+    #
+    #  The JSON representation for `Int32Value` is JSON number.
+    #
+    class Int32Value < ::Protobuf::Message
+      # The int32 value.
+      #
+      attr_accessor value(): ::Integer
+
+      def value!: () -> ::Integer?
+
+      def initialize: (?value: ::Integer) -> void
+
+      def []: (:value) -> ::Integer
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::Integer) -> ::Integer
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> Int32Value
+      end
+
+      # The type of `#initialize` parameter.
+      type init = Int32Value | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[Int32Value, Int32Value | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, Int32Value, Int32Value | _ToProto]
+
+      type array = ::Array[Int32Value | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, Int32Value | _ToProto]
+    end
+
+    # Wrapper message for `uint32`.
+    #
+    #  The JSON representation for `UInt32Value` is JSON number.
+    #
+    class UInt32Value < ::Protobuf::Message
+      # The uint32 value.
+      #
+      attr_accessor value(): ::Integer
+
+      def value!: () -> ::Integer?
+
+      def initialize: (?value: ::Integer) -> void
+
+      def []: (:value) -> ::Integer
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::Integer) -> ::Integer
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> UInt32Value
+      end
+
+      # The type of `#initialize` parameter.
+      type init = UInt32Value | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[UInt32Value, UInt32Value | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, UInt32Value, UInt32Value | _ToProto]
+
+      type array = ::Array[UInt32Value | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, UInt32Value | _ToProto]
+    end
+
+    # Wrapper message for `bool`.
+    #
+    #  The JSON representation for `BoolValue` is JSON `true` and `false`.
+    #
+    class BoolValue < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (BoolValue) -> String
+
+      # The bool value.
+      #
+      attr_accessor value(): bool
+
+      def value!: () -> bool?
+
+      def initialize: (?value: bool) -> void
+
+      def []: (:value) -> bool
+            | (::Symbol) -> untyped
+
+      def []=: (:value, bool) -> bool
+             | (::Symbol, untyped) -> untyped
+
+      def value?: () -> bool
+
+      interface _ToProto
+        def to_proto: () -> BoolValue
+      end
+
+      # The type of `#initialize` parameter.
+      type init = BoolValue | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[BoolValue, BoolValue | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, BoolValue, BoolValue | _ToProto]
+
+      type array = ::Array[BoolValue | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, BoolValue | _ToProto]
+    end
+
+    # Wrapper message for `string`.
+    #
+    #  The JSON representation for `StringValue` is JSON string.
+    #
+    class StringValue < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (StringValue) -> String
+
+      # The string value.
+      #
+      attr_accessor value(): ::String
+
+      def value!: () -> ::String?
+
+      def initialize: (?value: ::String) -> void
+
+      def []: (:value) -> ::String
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::String) -> ::String
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> StringValue
+      end
+
+      # The type of `#initialize` parameter.
+      type init = StringValue | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[StringValue, StringValue | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, StringValue, StringValue | _ToProto]
+
+      type array = ::Array[StringValue | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, StringValue | _ToProto]
+    end
+
+    # Wrapper message for `bytes`.
+    #
+    #  The JSON representation for `BytesValue` is JSON string.
+    #
+    class BytesValue < ::Protobuf::Message
+      # Encode the message to a binary string
+      #
+      def self.encode: (BytesValue) -> String
+
+      # The bytes value.
+      #
+      attr_accessor value(): ::String
+
+      def value!: () -> ::String?
+
+      def initialize: (?value: ::String) -> void
+
+      def []: (:value) -> ::String
+            | (::Symbol) -> untyped
+
+      def []=: (:value, ::String) -> ::String
+             | (::Symbol, untyped) -> untyped
+
+      interface _ToProto
+        def to_proto: () -> BytesValue
+      end
+
+      # The type of `#initialize` parameter.
+      type init = BytesValue | _ToProto
+
+      # The type of `repeated` field.
+      type field_array = ::Protobuf::Field::FieldArray[BytesValue, BytesValue | _ToProto]
+
+      # The type of `map` field.
+      type field_hash[KEY] = ::Protobuf::Field::FieldHash[KEY, BytesValue, BytesValue | _ToProto]
+
+      type array = ::Array[BytesValue | _ToProto]
+
+      type hash[KEY] = ::Hash[KEY, BytesValue | _ToProto]
+    end
+  end
+end