google-cloud-spanner 1.14.0 → 1.15.0

data/lib/google/cloud/spanner/admin/database/v1/database_admin_client_config.json

@@ -64,6 +64,46 @@
           "timeout_millis": 30000,
           "retry_codes_name": "non_idempotent",
           "retry_params_name": "default"
+        },
+        "CreateBackup": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "default"
+        },
+        "GetBackup": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "idempotent",
+          "retry_params_name": "default"
+        },
+        "UpdateBackup": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "default"
+        },
+        "DeleteBackup": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "idempotent",
+          "retry_params_name": "default"
+        },
+        "ListBackups": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "idempotent",
+          "retry_params_name": "default"
+        },
+        "RestoreDatabase": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "default"
+        },
+        "ListDatabaseOperations": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "idempotent",
+          "retry_params_name": "default"
+        },
+        "ListBackupOperations": {
+          "timeout_millis": 30000,
+          "retry_codes_name": "idempotent",
+          "retry_params_name": "default"
         }
       }
     }

data/lib/google/cloud/spanner/admin/database/v1/doc/google/protobuf/field_mask.rb

@@ -0,0 +1,222 @@
+# 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.
+
+
+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.
+    #
+    # In order to reset a field's value to the default, the field must
+    # be in the mask and set to the default value in the provided resource.
+    # Hence, in order to reset all fields of a resource, provide a default
+    # instance of the resource and set all fields in the mask, or do
+    # not provide a mask as described below.
+    #
+    # If a field mask is not present on update, the operation applies to
+    # all fields (as if a field mask of all fields has been specified).
+    # Note that in the presence of schema evolution, this may mean that
+    # fields the client does not know and has therefore not filled into
+    # the request will be reset to their default. If this is unwanted
+    # behavior, a specific service may require a client to always specify
+    # a field mask, producing an error if not.
+    #
+    # As with get operations, the location of the resource which
+    # describes the updated values in the request message depends on the
+    # operation kind. In any case, the effect of the field mask is
+    # required to be honored by the API.
+    #
+    # == 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 duplicated or unmappable.
+    # @!attribute [rw] paths
+    #   @return [Array<String>]
+    #     The set of field mask paths.
+    class FieldMask; end
+  end
+end

data/lib/google/cloud/spanner/admin/database/v1/doc/google/protobuf/timestamp.rb

@@ -0,0 +1,113 @@
+# 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.
+
+
+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; end
+  end
+end

data/lib/google/cloud/spanner/admin/database/v1/doc/google/spanner/admin/database/v1/backup.rb

@@ -0,0 +1,325 @@
+# 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.
+
+
+module Google
+  module Spanner
+    module Admin
+      module Database
+        module V1
+          # A backup of a Cloud Spanner database.
+          # @!attribute [rw] database
+          #   @return [String]
+          #     Required for the {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup} operation.
+          #     Name of the database from which this backup was
+          #     created. This needs to be in the same instance as the backup.
+          #     Values are of the form
+          #     `projects/<project>/instances/<instance>/databases/<database>`.
+          # @!attribute [rw] expire_time
+          #   @return [Google::Protobuf::Timestamp]
+          #     Required for the {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup}
+          #     operation. The expiration time of the backup, with microseconds
+          #     granularity that must be at least 6 hours and at most 366 days
+          #     from the time the CreateBackup request is processed. Once the `expire_time`
+          #     has passed, the backup is eligible to be automatically deleted by Cloud
+          #     Spanner to free the resources used by the backup.
+          # @!attribute [rw] name
+          #   @return [String]
+          #     Output only for the {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup} operation.
+          #     Required for the {Google::Spanner::Admin::Database::V1::DatabaseAdmin::UpdateBackup UpdateBackup} operation.
+          #
+          #     A globally unique identifier for the backup which cannot be
+          #     changed. Values are of the form
+          #     `projects/<project>/instances/<instance>/backups/[a-z][a-z0-9_\-]*[a-z0-9]`
+          #     The final segment of the name must be between 2 and 60 characters
+          #     in length.
+          #
+          #     The backup is stored in the location(s) specified in the instance
+          #     configuration of the instance containing the backup, identified
+          #     by the prefix of the backup name of the form
+          #     `projects/<project>/instances/<instance>`.
+          # @!attribute [rw] create_time
+          #   @return [Google::Protobuf::Timestamp]
+          #     Output only. The backup will contain an externally consistent
+          #     copy of the database at the timestamp specified by
+          #     `create_time`. `create_time` is approximately the time the
+          #     {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup} request is received.
+          # @!attribute [rw] size_bytes
+          #   @return [Integer]
+          #     Output only. Size of the backup in bytes.
+          # @!attribute [rw] state
+          #   @return [Google::Spanner::Admin::Database::V1::Backup::State]
+          #     Output only. The current state of the backup.
+          # @!attribute [rw] referencing_databases
+          #   @return [Array<String>]
+          #     Output only. The names of the restored databases that reference the backup.
+          #     The database names are of
+          #     the form `projects/<project>/instances/<instance>/databases/<database>`.
+          #     Referencing databases may exist in different instances. The existence of
+          #     any referencing database prevents the backup from being deleted. When a
+          #     restored database from the backup enters the `READY` state, the reference
+          #     to the backup is removed.
+          class Backup
+            # Indicates the current state of the backup.
+            module State
+              # Not specified.
+              STATE_UNSPECIFIED = 0
+
+              # The pending backup is still being created. Operations on the
+              # backup may fail with `FAILED_PRECONDITION` in this state.
+              CREATING = 1
+
+              # The backup is complete and ready for use.
+              READY = 2
+            end
+          end
+
+          # The request for {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup}.
+          # @!attribute [rw] parent
+          #   @return [String]
+          #     Required. The name of the instance in which the backup will be
+          #     created. This must be the same instance that contains the database the
+          #     backup will be created from. The backup will be stored in the
+          #     location(s) specified in the instance configuration of this
+          #     instance. Values are of the form
+          #     `projects/<project>/instances/<instance>`.
+          # @!attribute [rw] backup_id
+          #   @return [String]
+          #     Required. The id of the backup to be created. The `backup_id` appended to
+          #     `parent` forms the full backup name of the form
+          #     `projects/<project>/instances/<instance>/backups/<backup_id>`.
+          # @!attribute [rw] backup
+          #   @return [Google::Spanner::Admin::Database::V1::Backup]
+          #     Required. The backup to create.
+          class CreateBackupRequest; end
+
+          # Metadata type for the operation returned by
+          # {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup}.
+          # @!attribute [rw] name
+          #   @return [String]
+          #     The name of the backup being created.
+          # @!attribute [rw] database
+          #   @return [String]
+          #     The name of the database the backup is created from.
+          # @!attribute [rw] progress
+          #   @return [Google::Spanner::Admin::Database::V1::OperationProgress]
+          #     The progress of the
+          #     {Google::Spanner::Admin::Database::V1::DatabaseAdmin::CreateBackup CreateBackup} operation.
+          # @!attribute [rw] cancel_time
+          #   @return [Google::Protobuf::Timestamp]
+          #     The time at which cancellation of this operation was received.
+          #     {Google::Longrunning::Operations::CancelOperation Operations::CancelOperation}
+          #     starts asynchronous cancellation on a long-running operation. The server
+          #     makes a best effort to cancel the operation, but success is not guaranteed.
+          #     Clients can use
+          #     {Google::Longrunning::Operations::GetOperation Operations::GetOperation} or
+          #     other methods to check whether the cancellation succeeded or whether the
+          #     operation completed despite cancellation. On successful cancellation,
+          #     the operation is not deleted; instead, it becomes an operation with
+          #     an {Operation#error} value with a {Google::Rpc::Status#code} of 1,
+          #     corresponding to `Code.CANCELLED`.
+          class CreateBackupMetadata; end
+
+          # The request for {Google::Spanner::Admin::Database::V1::DatabaseAdmin::UpdateBackup UpdateBackup}.
+          # @!attribute [rw] backup
+          #   @return [Google::Spanner::Admin::Database::V1::Backup]
+          #     Required. The backup to update. `backup.name`, and the fields to be updated
+          #     as specified by `update_mask` are required. Other fields are ignored.
+          #     Update is only supported for the following fields:
+          #     * `backup.expire_time`.
+          # @!attribute [rw] update_mask
+          #   @return [Google::Protobuf::FieldMask]
+          #     Required. A mask specifying which fields (e.g. `expire_time`) in the
+          #     Backup resource should be updated. This mask is relative to the Backup
+          #     resource, not to the request message. The field mask must always be
+          #     specified; this prevents any future fields from being erased accidentally
+          #     by clients that do not know about them.
+          class UpdateBackupRequest; end
+
+          # The request for {Google::Spanner::Admin::Database::V1::DatabaseAdmin::GetBackup GetBackup}.
+          # @!attribute [rw] name
+          #   @return [String]
+          #     Required. Name of the backup.
+          #     Values are of the form
+          #     `projects/<project>/instances/<instance>/backups/<backup>`.
+          class GetBackupRequest; end
+
+          # The request for {Google::Spanner::Admin::Database::V1::DatabaseAdmin::DeleteBackup DeleteBackup}.
+          # @!attribute [rw] name
+          #   @return [String]
+          #     Required. Name of the backup to delete.
+          #     Values are of the form
+          #     `projects/<project>/instances/<instance>/backups/<backup>`.
+          class DeleteBackupRequest; end
+
+          # The request for {Google::Spanner::Admin::Database::V1::DatabaseAdmin::ListBackups ListBackups}.
+          # @!attribute [rw] parent
+          #   @return [String]
+          #     Required. The instance to list backups from.  Values are of the
+          #     form `projects/<project>/instances/<instance>`.
+          # @!attribute [rw] filter
+          #   @return [String]
+          #     An expression that filters the list of returned backups.
+          #
+          #     A filter expression consists of a field name, a comparison operator, and a
+          #     value for filtering.
+          #     The value must be a string, a number, or a boolean. The comparison operator
+          #     must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`.
+          #     Colon `:` is the contains operator. Filter rules are not case sensitive.
+          #
+          #     The following fields in the {Google::Spanner::Admin::Database::V1::Backup Backup} are eligible for filtering:
+          #
+          #     * `name`
+          #       * `database`
+          #       * `state`
+          #       * `create_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ)
+          #       * `expire_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ)
+          #       * `size_bytes`
+          #
+          #       You can combine multiple expressions by enclosing each expression in
+          #       parentheses. By default, expressions are combined with AND logic, but
+          #       you can specify AND, OR, and NOT logic explicitly.
+          #
+          #     Here are a few examples:
+          #
+          #     * `name:Howl` - The backup's name contains the string "howl".
+          #       * `database:prod`
+          #         * The database's name contains the string "prod".
+          #       * `state:CREATING` - The backup is pending creation.
+          #       * `state:READY` - The backup is fully created and ready for use.
+          #       * `(name:howl) AND (create_time < \"2018-03-28T14:50:00Z\")`
+          #         * The backup name contains the string "howl" and `create_time`
+          #           of the backup is before 2018-03-28T14:50:00Z.
+          #         * `expire_time < \"2018-03-28T14:50:00Z\"`
+          #           * The backup `expire_time` is before 2018-03-28T14:50:00Z.
+          #         * `size_bytes > 10000000000` - The backup's size is greater than 10GB
+          # @!attribute [rw] page_size
+          #   @return [Integer]
+          #     Number of backups to be returned in the response. If 0 or
+          #     less, defaults to the server's maximum allowed page size.
+          # @!attribute [rw] page_token
+          #   @return [String]
+          #     If non-empty, `page_token` should contain a
+          #     {Google::Spanner::Admin::Database::V1::ListBackupsResponse#next_page_token next_page_token} from a
+          #     previous {Google::Spanner::Admin::Database::V1::ListBackupsResponse ListBackupsResponse} to the same `parent` and with the same
+          #     `filter`.
+          class ListBackupsRequest; end
+
+          # The response for {Google::Spanner::Admin::Database::V1::DatabaseAdmin::ListBackups ListBackups}.
+          # @!attribute [rw] backups
+          #   @return [Array<Google::Spanner::Admin::Database::V1::Backup>]
+          #     The list of matching backups. Backups returned are ordered by `create_time`
+          #     in descending order, starting from the most recent `create_time`.
+          # @!attribute [rw] next_page_token
+          #   @return [String]
+          #     `next_page_token` can be sent in a subsequent
+          #     {Google::Spanner::Admin::Database::V1::DatabaseAdmin::ListBackups ListBackups} call to fetch more
+          #     of the matching backups.
+          class ListBackupsResponse; end
+
+          # The request for
+          # {Google::Spanner::Admin::Database::V1::DatabaseAdmin::ListBackupOperations ListBackupOperations}.
+          # @!attribute [rw] parent
+          #   @return [String]
+          #     Required. The instance of the backup operations. Values are of
+          #     the form `projects/<project>/instances/<instance>`.
+          # @!attribute [rw] filter
+          #   @return [String]
+          #     An expression that filters the list of returned backup operations.
+          #
+          #     A filter expression consists of a field name, a
+          #     comparison operator, and a value for filtering.
+          #     The value must be a string, a number, or a boolean. The comparison operator
+          #     must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`.
+          #     Colon `:` is the contains operator. Filter rules are not case sensitive.
+          #
+          #     The following fields in the {Google::Longrunning::Operation operation}
+          #     are eligible for filtering:
+          #
+          #     * `name` - The name of the long-running operation
+          #       * `done` - False if the operation is in progress, else true.
+          #       * `metadata.@type` - the type of metadata. For example, the type string
+          #         for {Google::Spanner::Admin::Database::V1::CreateBackupMetadata CreateBackupMetadata} is
+          #         `type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata`.
+          #       * `metadata.<field_name>` - any field in metadata.value.
+          #       * `error` - Error associated with the long-running operation.
+          #       * `response.@type` - the type of response.
+          #       * `response.<field_name>` - any field in response.value.
+          #
+          #       You can combine multiple expressions by enclosing each expression in
+          #       parentheses. By default, expressions are combined with AND logic, but
+          #       you can specify AND, OR, and NOT logic explicitly.
+          #
+          #     Here are a few examples:
+          #
+          #     * `done:true` - The operation is complete.
+          #       * `metadata.database:prod` - The database the backup was taken from has
+          #         a name containing the string "prod".
+          #       * `(metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND` <br/>
+          #         `(metadata.name:howl) AND` <br/>
+          #         `(metadata.progress.start_time < \"2018-03-28T14:50:00Z\") AND` <br/>
+          #         `(error:*)` - Returns operations where:
+          #         * The operation's metadata type is {Google::Spanner::Admin::Database::V1::CreateBackupMetadata CreateBackupMetadata}.
+          #         * The backup name contains the string "howl".
+          #         * The operation started before 2018-03-28T14:50:00Z.
+          #         * The operation resulted in an error.
+          # @!attribute [rw] page_size
+          #   @return [Integer]
+          #     Number of operations to be returned in the response. If 0 or
+          #     less, defaults to the server's maximum allowed page size.
+          # @!attribute [rw] page_token
+          #   @return [String]
+          #     If non-empty, `page_token` should contain a
+          #     {Google::Spanner::Admin::Database::V1::ListBackupOperationsResponse#next_page_token next_page_token}
+          #     from a previous {Google::Spanner::Admin::Database::V1::ListBackupOperationsResponse ListBackupOperationsResponse} to the
+          #     same `parent` and with the same `filter`.
+          class ListBackupOperationsRequest; end
+
+          # The response for
+          # {Google::Spanner::Admin::Database::V1::DatabaseAdmin::ListBackupOperations ListBackupOperations}.
+          # @!attribute [rw] operations
+          #   @return [Array<Google::Longrunning::Operation>]
+          #     The list of matching backup [long-running
+          #     operations][google.longrunning.Operation]. Each operation's name will be
+          #     prefixed by the backup's name and the operation's
+          #     {Google::Longrunning::Operation#metadata metadata} will be of type
+          #     {Google::Spanner::Admin::Database::V1::CreateBackupMetadata CreateBackupMetadata}. Operations returned include those that are
+          #     pending or have completed/failed/canceled within the last 7 days.
+          #     Operations returned are ordered by
+          #     `operation.metadata.value.progress.start_time` in descending order starting
+          #     from the most recently started operation.
+          # @!attribute [rw] next_page_token
+          #   @return [String]
+          #     `next_page_token` can be sent in a subsequent
+          #     {Google::Spanner::Admin::Database::V1::DatabaseAdmin::ListBackupOperations ListBackupOperations}
+          #     call to fetch more of the matching metadata.
+          class ListBackupOperationsResponse; end
+
+          # Information about a backup.
+          # @!attribute [rw] backup
+          #   @return [String]
+          #     Name of the backup.
+          # @!attribute [rw] create_time
+          #   @return [Google::Protobuf::Timestamp]
+          #     The backup contains an externally consistent copy of `source_database` at
+          #     the timestamp specified by `create_time`.
+          # @!attribute [rw] source_database
+          #   @return [String]
+          #     Name of the database the backup was created from.
+          class BackupInfo; end
+        end
+      end
+    end
+  end
+end