google-cloud-document_ai-v1beta3 0.1.0

data/proto_docs/google/protobuf/timestamp.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
+
+
+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 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.
+    # @!attribute [rw] seconds
+    #   @return [::Integer]
+    #     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.
+    # @!attribute [rw] nanos
+    #   @return [::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.
+    class Timestamp
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+  end
+end

data/proto_docs/google/protobuf/wrappers.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
+
+
+module Google
+  module Protobuf
+    # Wrapper message for `double`.
+    #
+    # The JSON representation for `DoubleValue` is JSON number.
+    # @!attribute [rw] value
+    #   @return [::Float]
+    #     The double value.
+    class DoubleValue
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `float`.
+    #
+    # The JSON representation for `FloatValue` is JSON number.
+    # @!attribute [rw] value
+    #   @return [::Float]
+    #     The float value.
+    class FloatValue
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `int64`.
+    #
+    # The JSON representation for `Int64Value` is JSON string.
+    # @!attribute [rw] value
+    #   @return [::Integer]
+    #     The int64 value.
+    class Int64Value
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `uint64`.
+    #
+    # The JSON representation for `UInt64Value` is JSON string.
+    # @!attribute [rw] value
+    #   @return [::Integer]
+    #     The uint64 value.
+    class UInt64Value
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `int32`.
+    #
+    # The JSON representation for `Int32Value` is JSON number.
+    # @!attribute [rw] value
+    #   @return [::Integer]
+    #     The int32 value.
+    class Int32Value
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `uint32`.
+    #
+    # The JSON representation for `UInt32Value` is JSON number.
+    # @!attribute [rw] value
+    #   @return [::Integer]
+    #     The uint32 value.
+    class UInt32Value
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `bool`.
+    #
+    # The JSON representation for `BoolValue` is JSON `true` and `false`.
+    # @!attribute [rw] value
+    #   @return [::Boolean]
+    #     The bool value.
+    class BoolValue
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `string`.
+    #
+    # The JSON representation for `StringValue` is JSON string.
+    # @!attribute [rw] value
+    #   @return [::String]
+    #     The string value.
+    class StringValue
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+
+    # Wrapper message for `bytes`.
+    #
+    # The JSON representation for `BytesValue` is JSON string.
+    # @!attribute [rw] value
+    #   @return [::String]
+    #     The bytes value.
+    class BytesValue
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+  end
+end

data/proto_docs/google/rpc/status.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
+
+
+module Google
+  module Rpc
+    # The `Status` type defines a logical error model that is suitable for
+    # different programming environments, including REST APIs and RPC APIs. It is
+    # used by [gRPC](https://github.com/grpc). Each `Status` message contains
+    # three pieces of data: error code, error message, and error details.
+    #
+    # You can find out more about this error model and how to work with it in the
+    # [API Design Guide](https://cloud.google.com/apis/design/errors).
+    # @!attribute [rw] code
+    #   @return [::Integer]
+    #     The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+    # @!attribute [rw] message
+    #   @return [::String]
+    #     A developer-facing error message, which should be in English. Any
+    #     user-facing error message should be localized and sent in the
+    #     {::Google::Rpc::Status#details google.rpc.Status.details} field, or localized by the client.
+    # @!attribute [rw] details
+    #   @return [::Array<::Google::Protobuf::Any>]
+    #     A list of messages that carry the error details.  There is a common set of
+    #     message types for APIs to use.
+    class Status
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+  end
+end

data/proto_docs/google/type/color.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
+
+
+module Google
+  module Type
+    # Represents a color in the RGBA color space. This representation is designed
+    # for simplicity of conversion to/from color representations in various
+    # languages over compactness; for example, the fields of this representation
+    # can be trivially provided to the constructor of "java.awt.Color" in Java; it
+    # can also be trivially provided to UIColor's "+colorWithRed:green:blue:alpha"
+    # method in iOS; and, with just a little work, it can be easily formatted into
+    # a CSS "rgba()" string in JavaScript, as well.
+    #
+    # Note: this proto does not carry information about the absolute color space
+    # that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB,
+    # DCI-P3, BT.2020, etc.). By default, applications SHOULD assume the sRGB color
+    # space.
+    #
+    # Example (Java):
+    #
+    #      import com.google.type.Color;
+    #
+    #      // ...
+    #      public static java.awt.Color fromProto(Color protocolor) {
+    #        float alpha = protocolor.hasAlpha()
+    #            ? protocolor.getAlpha().getValue()
+    #            : 1.0;
+    #
+    #        return new java.awt.Color(
+    #            protocolor.getRed(),
+    #            protocolor.getGreen(),
+    #            protocolor.getBlue(),
+    #            alpha);
+    #      }
+    #
+    #      public static Color toProto(java.awt.Color color) {
+    #        float red = (float) color.getRed();
+    #        float green = (float) color.getGreen();
+    #        float blue = (float) color.getBlue();
+    #        float denominator = 255.0;
+    #        Color.Builder resultBuilder =
+    #            Color
+    #                .newBuilder()
+    #                .setRed(red / denominator)
+    #                .setGreen(green / denominator)
+    #                .setBlue(blue / denominator);
+    #        int alpha = color.getAlpha();
+    #        if (alpha != 255) {
+    #          result.setAlpha(
+    #              FloatValue
+    #                  .newBuilder()
+    #                  .setValue(((float) alpha) / denominator)
+    #                  .build());
+    #        }
+    #        return resultBuilder.build();
+    #      }
+    #      // ...
+    #
+    # Example (iOS / Obj-C):
+    #
+    #      // ...
+    #      static UIColor* fromProto(Color* protocolor) {
+    #         float red = [protocolor red];
+    #         float green = [protocolor green];
+    #         float blue = [protocolor blue];
+    #         FloatValue* alpha_wrapper = [protocolor alpha];
+    #         float alpha = 1.0;
+    #         if (alpha_wrapper != nil) {
+    #           alpha = [alpha_wrapper value];
+    #         }
+    #         return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
+    #      }
+    #
+    #      static Color* toProto(UIColor* color) {
+    #          CGFloat red, green, blue, alpha;
+    #          if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
+    #            return nil;
+    #          }
+    #          Color* result = [[Color alloc] init];
+    #          [result setRed:red];
+    #          [result setGreen:green];
+    #          [result setBlue:blue];
+    #          if (alpha <= 0.9999) {
+    #            [result setAlpha:floatWrapperWithValue(alpha)];
+    #          }
+    #          [result autorelease];
+    #          return result;
+    #     }
+    #     // ...
+    #
+    #  Example (JavaScript):
+    #
+    #     // ...
+    #
+    #     var protoToCssColor = function(rgb_color) {
+    #        var redFrac = rgb_color.red || 0.0;
+    #        var greenFrac = rgb_color.green || 0.0;
+    #        var blueFrac = rgb_color.blue || 0.0;
+    #        var red = Math.floor(redFrac * 255);
+    #        var green = Math.floor(greenFrac * 255);
+    #        var blue = Math.floor(blueFrac * 255);
+    #
+    #        if (!('alpha' in rgb_color)) {
+    #           return rgbToCssColor_(red, green, blue);
+    #        }
+    #
+    #        var alphaFrac = rgb_color.alpha.value || 0.0;
+    #        var rgbParams = [red, green, blue].join(',');
+    #        return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
+    #     };
+    #
+    #     var rgbToCssColor_ = function(red, green, blue) {
+    #       var rgbNumber = new Number((red << 16) | (green << 8) | blue);
+    #       var hexString = rgbNumber.toString(16);
+    #       var missingZeros = 6 - hexString.length;
+    #       var resultBuilder = ['#'];
+    #       for (var i = 0; i < missingZeros; i++) {
+    #          resultBuilder.push('0');
+    #       }
+    #       resultBuilder.push(hexString);
+    #       return resultBuilder.join('');
+    #     };
+    #
+    #     // ...
+    # @!attribute [rw] red
+    #   @return [::Float]
+    #     The amount of red in the color as a value in the interval [0, 1].
+    # @!attribute [rw] green
+    #   @return [::Float]
+    #     The amount of green in the color as a value in the interval [0, 1].
+    # @!attribute [rw] blue
+    #   @return [::Float]
+    #     The amount of blue in the color as a value in the interval [0, 1].
+    # @!attribute [rw] alpha
+    #   @return [::Google::Protobuf::FloatValue]
+    #     The fraction of this color that should be applied to the pixel. That is,
+    #     the final pixel color is defined by the equation:
+    #
+    #       pixel color = alpha * (this color) + (1.0 - alpha) * (background color)
+    #
+    #     This means that a value of 1.0 corresponds to a solid color, whereas
+    #     a value of 0.0 corresponds to a completely transparent color. This
+    #     uses a wrapper message rather than a simple float scalar so that it is
+    #     possible to distinguish between a default value and the value being unset.
+    #     If omitted, this color object is to be rendered as a solid color
+    #     (as if the alpha value had been explicitly given with a value of 1.0).
+    class Color
+      include ::Google::Protobuf::MessageExts
+      extend ::Google::Protobuf::MessageExts::ClassMethods
+    end
+  end
+end