diff --git a/gcloud-sdk/genproto/google.cloud.batch.v1.rs b/gcloud-sdk/genproto/google.cloud.batch.v1.rs index c3c379ff6..dce81d151 100644 --- a/gcloud-sdk/genproto/google.cloud.batch.v1.rs +++ b/gcloud-sdk/genproto/google.cloud.batch.v1.rs @@ -612,6 +612,9 @@ pub struct AllocationPolicy { /// Only instances\[0\] is supported now. #[prost(message, repeated, tag="8")] pub instances: ::prost::alloc::vec::Vec, + /// Service account that VMs will run as. + #[prost(message, optional, tag="9")] + pub service_account: ::core::option::Option, /// Labels applied to all VM instances and other resources /// created by AllocationPolicy. /// Labels could be user provided or system generated. @@ -687,7 +690,9 @@ pub mod allocation_policy { #[derive(Clone, PartialEq, ::prost::Message)] pub struct AttachedDisk { /// Device name that the guest operating system will see. - /// If not specified, this is default to the disk name. + /// It is used by Runnable.volumes field to mount disks. So please specify + /// the device_name if you want Batch to help mount the disk, and it should + /// match the device_name field in volumes. #[prost(string, tag="3")] pub device_name: ::prost::alloc::string::String, #[prost(oneof="attached_disk::Attached", tags="1, 2")] @@ -714,6 +719,7 @@ pub mod allocation_policy { /// The number of accelerators of this type. #[prost(int64, tag="2")] pub count: i64, + /// Deprecated: please use instances\[0\].install_gpu_drivers instead. #[deprecated] #[prost(bool, tag="3")] pub install_gpu_drivers: bool, @@ -746,6 +752,12 @@ pub mod allocation_policy { /// Either an InstancePolicy or an instance template. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstancePolicyOrTemplate { + /// Set this field true if users want Batch to help fetch drivers from a + /// third party location and install them for GPUs specified in + /// policy.accelerators or instance_template on their behalf. Default is + /// false. + #[prost(bool, tag="3")] + pub install_gpu_drivers: bool, #[prost(oneof="instance_policy_or_template::PolicyTemplate", tags="1, 2")] pub policy_template: ::core::option::Option, } @@ -871,6 +883,16 @@ pub struct TaskGroup { #[prost(bool, tag="12")] pub permissive_ssh: bool, } +/// Carries information about a Google Cloud service account. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ServiceAccount { + /// Email address of the service account. If not specified, the default + /// Compute Engine service account for the project will be used. If instance + /// template is being used, the service account has to be specified in the + /// instance template and it has to match the email field here. + #[prost(string, tag="1")] + pub email: ::prost::alloc::string::String, +} /// CreateJob Request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateJobRequest { diff --git a/gcloud-sdk/genproto/google.cloud.batch.v1alpha.rs b/gcloud-sdk/genproto/google.cloud.batch.v1alpha.rs index 9488ccded..2493aeb81 100644 --- a/gcloud-sdk/genproto/google.cloud.batch.v1alpha.rs +++ b/gcloud-sdk/genproto/google.cloud.batch.v1alpha.rs @@ -466,7 +466,7 @@ pub struct Job { /// Output only. Job status. It is read only for users. #[prost(message, optional, tag="9")] pub status: ::core::option::Option, - /// Job notification. + /// Deprecated: please use notifications instead. #[deprecated] #[prost(message, optional, tag="10")] pub notification: ::core::option::Option, @@ -739,7 +739,7 @@ pub struct AllocationPolicy { /// Location where compute resources should be allocated for the Job. #[prost(message, optional, tag="1")] pub location: ::core::option::Option, - /// Create only instances allowed by this policy. + /// Deprecated: please use instances\[0\].policy instead. #[deprecated] #[prost(message, optional, tag="2")] pub instance: ::core::option::Option, @@ -747,25 +747,19 @@ pub struct AllocationPolicy { /// Only instances\[0\] is supported now. #[prost(message, repeated, tag="8")] pub instances: ::prost::alloc::vec::Vec, - /// Instance templates that are used to VMs. - /// If specified, only instance_templates\[0\] is used. + /// Deprecated: please use instances\[0\].template instead. #[deprecated] #[prost(string, repeated, tag="3")] pub instance_templates: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - /// Create only instances in the listed provisiong models. - /// Default to allow all. - /// - /// Currently only the first model of the provisioning_models list will be - /// considered; specifying additional models (e.g., 2nd, 3rd, etc.) is a no-op. + /// Deprecated: please use instances\[i\].policy.provisioning_model instead. #[deprecated] #[prost(enumeration="allocation_policy::ProvisioningModel", repeated, packed="false", tag="4")] pub provisioning_models: ::prost::alloc::vec::Vec, - /// Email of the service account that VMs will run as. + /// Deprecated: please use service_account instead. #[deprecated] #[prost(string, tag="5")] pub service_account_email: ::prost::alloc::string::String, /// Service account that VMs will run as. - /// Not yet implemented. #[prost(message, optional, tag="9")] pub service_account: ::core::option::Option, /// Labels applied to all VM instances and other resources @@ -848,7 +842,9 @@ pub mod allocation_policy { #[derive(Clone, PartialEq, ::prost::Message)] pub struct AttachedDisk { /// Device name that the guest operating system will see. - /// If not specified, this is default to the disk name. + /// It is used by Runnable.volumes field to mount disks. So please specify + /// the device_name if you want Batch to help mount the disk, and it should + /// match the device_name field in volumes. #[prost(string, tag="3")] pub device_name: ::prost::alloc::string::String, #[prost(oneof="attached_disk::Attached", tags="1, 2")] @@ -875,6 +871,7 @@ pub mod allocation_policy { /// The number of accelerators of this type. #[prost(int64, tag="2")] pub count: i64, + /// Deprecated: please use instances\[0\].install_gpu_drivers instead. #[deprecated] #[prost(bool, tag="3")] pub install_gpu_drivers: bool, @@ -883,6 +880,7 @@ pub mod allocation_policy { /// created by this InstancePolicy. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstancePolicy { + /// Deprecated: please use machine_type instead. #[deprecated] #[prost(string, repeated, tag="1")] pub allowed_machine_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, @@ -910,6 +908,10 @@ pub mod allocation_policy { /// Either an InstancePolicy or an instance template. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstancePolicyOrTemplate { + /// Set this field true if users want Batch to help fetch drivers from a + /// third party location and install them for GPUs specified in + /// policy.accelerators or instance_template on their behalf. Default is + /// false. #[prost(bool, tag="3")] pub install_gpu_drivers: bool, #[prost(oneof="instance_policy_or_template::PolicyTemplate", tags="1, 2")] @@ -1080,11 +1082,14 @@ pub mod task_group { #[derive(Clone, PartialEq, ::prost::Message)] pub struct ServiceAccount { /// Email address of the service account. If not specified, the default - /// Compute Engine service account for the project will be used. + /// Compute Engine service account for the project will be used. If instance + /// template is being used, the service account has to be specified in the + /// instance template and it has to match the email field here. #[prost(string, tag="1")] pub email: ::prost::alloc::string::String, /// List of scopes to be enabled for this service account on the VM, in /// addition to the cloud-platform API scope that will be added by default. + #[deprecated] #[prost(string, repeated, tag="2")] pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } diff --git a/gcloud-sdk/genproto/google.cloud.channel.v1.rs b/gcloud-sdk/genproto/google.cloud.channel.v1.rs index b0aef194b..f4fc0243c 100644 --- a/gcloud-sdk/genproto/google.cloud.channel.v1.rs +++ b/gcloud-sdk/genproto/google.cloud.channel.v1.rs @@ -1119,6 +1119,531 @@ pub mod operation_metadata { } } } +/// Request message for \[CloudChannelReportsService.RunReportJob][google.cloud.channel.v1.CloudChannelReportsService.RunReportJob\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RunReportJobRequest { + /// Required. The report's resource name. Specifies the account and report used to + /// generate report data. The report_id identifier is a UID (for example, + /// `613bf59q`). + /// Name uses the format: + /// accounts/{account_id}/reports/{report_id} + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Optional. The range of usage or invoice dates to include in the result. + #[prost(message, optional, tag="2")] + pub date_range: ::core::option::Option, + /// Optional. A structured string that defines conditions on dimension columns to + /// restrict the report output. + /// + /// Filters support logical operators (AND, OR, NOT) and conditional operators + /// (=, !=, <, >, <=, and >=) using `column_id` as keys. + /// + /// For example: + /// `(customer:"accounts/C123abc/customers/S456def" OR + /// customer:"accounts/C123abc/customers/S789ghi") AND + /// invoice_start_date.year >= 2022` + #[prost(string, tag="3")] + pub filter: ::prost::alloc::string::String, + /// Optional. The BCP-47 language code, such as "en-US". If specified, the + /// response is localized to the corresponding language code if the + /// original data sources support it. + /// Default is "en-US". + #[prost(string, tag="4")] + pub language_code: ::prost::alloc::string::String, +} +/// Response message for \[CloudChannelReportsService.RunReportJob][google.cloud.channel.v1.CloudChannelReportsService.RunReportJob\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RunReportJobResponse { + /// Pass `report_job.name` to \[FetchReportResultsRequest.report_job][google.cloud.channel.v1.FetchReportResultsRequest.report_job\] + /// to retrieve the report's results. + #[prost(message, optional, tag="1")] + pub report_job: ::core::option::Option, + /// The metadata for the report's results (display name, columns, row count, + /// and date range). If you view this before the operation finishes, + /// you may see incomplete data. + #[prost(message, optional, tag="2")] + pub report_metadata: ::core::option::Option, +} +/// Request message for \[CloudChannelReportsService.FetchReportResults][google.cloud.channel.v1.CloudChannelReportsService.FetchReportResults\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FetchReportResultsRequest { + /// Required. The report job created by \[CloudChannelReportsService.RunReportJob][google.cloud.channel.v1.CloudChannelReportsService.RunReportJob\]. + /// Report_job uses the format: + /// accounts/{account_id}/reportJobs/{report_job_id} + #[prost(string, tag="1")] + pub report_job: ::prost::alloc::string::String, + /// Optional. Requested page size of the report. The server may return fewer results than + /// requested. If you don't specify a page size, the server uses a sensible + /// default (may change over time). + /// + /// The maximum value is 30,000; the server will change larger values to + /// 30,000. + #[prost(int32, tag="2")] + pub page_size: i32, + /// Optional. A token that specifies a page of results beyond the first page. + /// Obtained through + /// \[FetchReportResultsResponse.next_page_token][google.cloud.channel.v1.FetchReportResultsResponse.next_page_token\] of the previous + /// \[CloudChannelReportsService.FetchReportResults][google.cloud.channel.v1.CloudChannelReportsService.FetchReportResults\] call. + #[prost(string, tag="3")] + pub page_token: ::prost::alloc::string::String, +} +/// Response message for \[CloudChannelReportsService.FetchReportResults][google.cloud.channel.v1.CloudChannelReportsService.FetchReportResults\]. +/// Contains a tabular representation of the report results. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FetchReportResultsResponse { + /// The metadata for the report results (display name, columns, row count, and + /// date ranges). + #[prost(message, optional, tag="1")] + pub report_metadata: ::core::option::Option, + /// The report's lists of values. Each row follows the settings and ordering + /// of the columns from `report_metadata`. + #[prost(message, repeated, tag="2")] + pub rows: ::prost::alloc::vec::Vec, + /// Pass this token to \[FetchReportResultsRequest.page_token][google.cloud.channel.v1.FetchReportResultsRequest.page_token\] to retrieve + /// the next page of results. + #[prost(string, tag="3")] + pub next_page_token: ::prost::alloc::string::String, +} +/// Request message for \[CloudChannelReportsService.ListReports][google.cloud.channel.v1.CloudChannelReportsService.ListReports\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListReportsRequest { + /// Required. The resource name of the partner account to list available reports for. + /// Parent uses the format: + /// accounts/{account_id} + #[prost(string, tag="1")] + pub parent: ::prost::alloc::string::String, + /// Optional. Requested page size of the report. The server might return fewer results + /// than requested. If unspecified, returns 20 reports. + /// The maximum value is 100. + #[prost(int32, tag="2")] + pub page_size: i32, + /// Optional. A token that specifies a page of results beyond the first page. + /// Obtained through + /// \[ListReportsResponse.next_page_token][google.cloud.channel.v1.ListReportsResponse.next_page_token\] of the previous + /// \[CloudChannelReportsService.ListReports][google.cloud.channel.v1.CloudChannelReportsService.ListReports\] call. + #[prost(string, tag="3")] + pub page_token: ::prost::alloc::string::String, + /// Optional. The BCP-47 language code, such as "en-US". If specified, the + /// response is localized to the corresponding language code if the + /// original data sources support it. + /// Default is "en-US". + #[prost(string, tag="4")] + pub language_code: ::prost::alloc::string::String, +} +/// Response message for \[CloudChannelReportsService.ListReports][google.cloud.channel.v1.CloudChannelReportsService.ListReports\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListReportsResponse { + /// The reports available to the partner. + #[prost(message, repeated, tag="1")] + pub reports: ::prost::alloc::vec::Vec, + /// Pass this token to \[FetchReportResultsRequest.page_token][google.cloud.channel.v1.FetchReportResultsRequest.page_token\] to retrieve + /// the next page of results. + #[prost(string, tag="2")] + pub next_page_token: ::prost::alloc::string::String, +} +/// The result of a \[RunReportJob][\] operation. Contains the name to use in +/// \[FetchReportResultsRequest.report_job][google.cloud.channel.v1.FetchReportResultsRequest.report_job\] and the status of the operation. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReportJob { + /// Required. The resource name of a report job. + /// Name uses the format: + /// `accounts/{account_id}/reportJobs/{report_job_id}` + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The current status of report generation. + #[prost(message, optional, tag="2")] + pub report_status: ::core::option::Option, +} +/// The features describing the data. Returned by +/// \[CloudChannelReportsService.RunReportJob][google.cloud.channel.v1.CloudChannelReportsService.RunReportJob\] and +/// \[CloudChannelReportsService.FetchReportResults][google.cloud.channel.v1.CloudChannelReportsService.FetchReportResults\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReportResultsMetadata { + /// Details of the completed report. + #[prost(message, optional, tag="1")] + pub report: ::core::option::Option, + /// The total number of rows of data in the final report. + #[prost(int64, tag="2")] + pub row_count: i64, + /// The date range of reported usage. + #[prost(message, optional, tag="3")] + pub date_range: ::core::option::Option, + /// The usage dates immediately preceding `date_range` with the same duration. + /// Use this to calculate trending usage and costs. This is only populated if + /// you request trending data. + /// + /// For example, if `date_range` is July 1-15, `preceding_date_range` will be + /// June 16-30. + #[prost(message, optional, tag="4")] + pub preceding_date_range: ::core::option::Option, +} +/// The definition of a report column. Specifies the data properties +/// in the corresponding position of the report rows. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Column { + /// The unique name of the column (for example, customer_domain, + /// channel_partner, customer_cost). You can use column IDs in + /// \[RunReportJobRequest.filter][google.cloud.channel.v1.RunReportJobRequest.filter\]. + /// To see all reports and their columns, call + /// \[CloudChannelReportsService.ListReports][google.cloud.channel.v1.CloudChannelReportsService.ListReports\]. + #[prost(string, tag="1")] + pub column_id: ::prost::alloc::string::String, + /// The column's display name. + #[prost(string, tag="2")] + pub display_name: ::prost::alloc::string::String, + /// The type of the values for this column. + #[prost(enumeration="column::DataType", tag="3")] + pub data_type: i32, +} +/// Nested message and enum types in `Column`. +pub mod column { + /// Available data types for columns. Corresponds to the fields in the + /// ReportValue `oneof` field. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum DataType { + /// Not used. + Unspecified = 0, + /// ReportValues for this column will use string_value. + String = 1, + /// ReportValues for this column will use int_value. + Int = 2, + /// ReportValues for this column will use decimal_value. + Decimal = 3, + /// ReportValues for this column will use money_value. + Money = 4, + /// ReportValues for this column will use date_value. + Date = 5, + /// ReportValues for this column will use date_time_value. + DateTime = 6, + } + impl DataType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DataType::Unspecified => "DATA_TYPE_UNSPECIFIED", + DataType::String => "STRING", + DataType::Int => "INT", + DataType::Decimal => "DECIMAL", + DataType::Money => "MONEY", + DataType::Date => "DATE", + DataType::DateTime => "DATE_TIME", + } + } + } +} +/// A representation of usage or invoice date ranges. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DateRange { + /// The earliest usage date time (inclusive). + /// + /// If you use time groupings (daily, weekly, etc), each group uses + /// midnight to midnight (Pacific time). The usage start date is + /// rounded down to include all usage from the specified date. We recommend + /// that clients pass `usage_start_date_time` in Pacific time. + #[prost(message, optional, tag="1")] + pub usage_start_date_time: ::core::option::Option, + /// The latest usage date time (exclusive). + /// + /// If you use time groupings (daily, weekly, etc), each group uses + /// midnight to midnight (Pacific time). The usage end date is + /// rounded down to include all usage from the specified date. We recommend + /// that clients pass `usage_start_date_time` in Pacific time. + #[prost(message, optional, tag="2")] + pub usage_end_date_time: ::core::option::Option, + /// The earliest invoice date (inclusive). + /// + /// If your product uses monthly invoices, and this value is not the beginning + /// of a month, this will adjust the date to the first day of the given month. + #[prost(message, optional, tag="3")] + pub invoice_start_date: ::core::option::Option, + /// The latest invoice date (exclusive). + /// + /// If your product uses monthly invoices, and this value is not the beginning + /// of a month, this will adjust the date to the first day of the following + /// month. + #[prost(message, optional, tag="4")] + pub invoice_end_date: ::core::option::Option, +} +/// A row of report values. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Row { + /// The list of values in the row. + #[prost(message, repeated, tag="1")] + pub values: ::prost::alloc::vec::Vec, +} +/// A single report value. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReportValue { + /// A single report value. + #[prost(oneof="report_value::Value", tags="1, 2, 3, 4, 5, 6")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `ReportValue`. +pub mod report_value { + /// A single report value. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// A value of type `string`. + #[prost(string, tag="1")] + StringValue(::prost::alloc::string::String), + /// A value of type `int`. + #[prost(int64, tag="2")] + IntValue(i64), + /// A value of type `google.type.Decimal`, representing non-integer numeric + /// values. + #[prost(message, tag="3")] + DecimalValue(super::super::super::super::r#type::Decimal), + /// A value of type `google.type.Money` (currency code, whole units, decimal + /// units). + #[prost(message, tag="4")] + MoneyValue(super::super::super::super::r#type::Money), + /// A value of type `google.type.Date` (year, month, day). + #[prost(message, tag="5")] + DateValue(super::super::super::super::r#type::Date), + /// A value of type `google.type.DateTime` (year, month, day, hour, minute, + /// second, and UTC offset or timezone.) + #[prost(message, tag="6")] + DateTimeValue(super::super::super::super::r#type::DateTime), + } +} +/// Status of a report generation process. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReportStatus { + /// The current state of the report generation process. + #[prost(enumeration="report_status::State", tag="1")] + pub state: i32, + /// The report generation's start time. + #[prost(message, optional, tag="2")] + pub start_time: ::core::option::Option<::prost_types::Timestamp>, + /// The report generation's completion time. + #[prost(message, optional, tag="3")] + pub end_time: ::core::option::Option<::prost_types::Timestamp>, +} +/// Nested message and enum types in `ReportStatus`. +pub mod report_status { + /// Available states of report generation. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum State { + /// Not used. + Unspecified = 0, + /// Report processing started. + Started = 1, + /// Data generated from the report is being staged. + Writing = 2, + /// Report data is available for access. + Available = 3, + /// Report failed. + Failed = 4, + } + impl State { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + State::Unspecified => "STATE_UNSPECIFIED", + State::Started => "STARTED", + State::Writing => "WRITING", + State::Available => "AVAILABLE", + State::Failed => "FAILED", + } + } + } +} +/// The ID and description of a report that was used to generate report data. +/// For example, "GCP Daily Spend", "Google Workspace License Activity", etc. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Report { + /// Required. The report's resource name. Specifies the account and report used to + /// generate report data. The report_id identifier is a UID + /// (for example, `613bf59q`). + /// + /// Name uses the format: + /// accounts/{account_id}/reports/{report_id} + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// A human-readable name for this report. + #[prost(string, tag="2")] + pub display_name: ::prost::alloc::string::String, + /// The list of columns included in the report. This defines the schema of + /// the report results. + #[prost(message, repeated, tag="3")] + pub columns: ::prost::alloc::vec::Vec, + /// A description of other aspects of the report, such as the products + /// it supports. + #[prost(string, tag="4")] + pub description: ::prost::alloc::string::String, +} +/// Generated client implementations. +pub mod cloud_channel_reports_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// CloudChannelReportsService lets Google Cloud resellers and + /// distributors retrieve and combine a variety of data in Cloud Channel for + /// multiple products (Google Cloud Platform (GCP), Google Voice, and + /// Google Workspace.) + #[derive(Debug, Clone)] + pub struct CloudChannelReportsServiceClient { + inner: tonic::client::Grpc, + } + impl CloudChannelReportsServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: std::convert::TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl CloudChannelReportsServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> CloudChannelReportsServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + CloudChannelReportsServiceClient::new( + InterceptedService::new(inner, interceptor), + ) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Begins generation of data for a given report. The report + /// identifier is a UID (for example, `613bf59q`). + /// + /// Possible error codes: + /// + /// * PERMISSION_DENIED: The user doesn't have access to this report. + /// * INVALID_ARGUMENT: Required request parameters are missing + /// or invalid. + /// * NOT_FOUND: The report identifier was not found. + /// * INTERNAL: Any non-user error related to a technical issue + /// in the backend. Contact Cloud Channel support. + /// * UNKNOWN: Any non-user error related to a technical issue + /// in the backend. Contact Cloud Channel support. + /// + /// Return value: + /// The ID of a long-running operation. + /// + /// To get the results of the operation, call the GetOperation method of + /// CloudChannelOperationsService. The Operation metadata contains an + /// instance of [OperationMetadata][google.cloud.channel.v1.OperationMetadata]. + /// + /// To get the results of report generation, call + /// [CloudChannelReportsService.FetchReportResults][google.cloud.channel.v1.CloudChannelReportsService.FetchReportResults] with the + /// [RunReportJobResponse.report_job][google.cloud.channel.v1.RunReportJobResponse.report_job]. + pub async fn run_report_job( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.channel.v1.CloudChannelReportsService/RunReportJob", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Retrieves data generated by [CloudChannelReportsService.RunReportJob][google.cloud.channel.v1.CloudChannelReportsService.RunReportJob]. + pub async fn fetch_report_results( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.channel.v1.CloudChannelReportsService/FetchReportResults", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Lists the reports that RunReportJob can run. These reports include an ID, + /// a description, and the list of columns that will be in the result. + pub async fn list_reports( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.channel.v1.CloudChannelReportsService/ListReports", + ); + self.inner.unary(request.into_request(), path, codec).await + } + } +} /// Configuration for how a reseller will reprice a Customer. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CustomerRepricingConfig { @@ -1491,7 +2016,7 @@ pub struct ListTransferableSkusRequest { /// Optional. #[prost(string, tag="3")] pub page_token: ::prost::alloc::string::String, - /// The super admin of the resold customer generates this token to + /// Optional. The super admin of the resold customer generates this token to /// authorize a reseller to access their Cloud Identity and purchase /// entitlements on their behalf. You can omit this token after authorization. /// See for more details. @@ -1559,7 +2084,7 @@ pub struct ListTransferableOffersRequest { /// Required. The SKU to look up Offers for. #[prost(string, tag="6")] pub sku: ::prost::alloc::string::String, - /// The BCP-47 language code. For example, "en-US". The + /// Optional. The BCP-47 language code. For example, "en-US". The /// response will localize in the corresponding language code, if specified. /// The default value is "en-US". #[prost(string, tag="7")] @@ -2924,7 +3449,8 @@ pub mod cloud_channel_service_client { /// /// * PERMISSION_DENIED: /// * The customer doesn't belong to the reseller and has no auth token. - /// * The supplied auth token is invalid. + /// * The customer provided incorrect reseller information when generating + /// auth token. /// * The reseller account making the request is different /// from the reseller account in the query. /// * INVALID_ARGUMENT: Required request parameters are missing or invalid. diff --git a/gcloud-sdk/genproto/google.cloud.compute.v1.rs b/gcloud-sdk/genproto/google.cloud.compute.v1.rs index f4b5b7110..ea05a136e 100644 --- a/gcloud-sdk/genproto/google.cloud.compute.v1.rs +++ b/gcloud-sdk/genproto/google.cloud.compute.v1.rs @@ -594,6 +594,10 @@ pub struct Address { /// Check the IpVersion enum for the list of possible values. #[prost(string, optional, tag="294959552")] pub ip_version: ::core::option::Option<::prost::alloc::string::String>, + /// The endpoint type of this address, which should be VM or NETLB. This is used for deciding which type of endpoint this address can be used after the external IPv6 address reservation. + /// Check the Ipv6EndpointType enum for the list of possible values. + #[prost(string, optional, tag="97501004")] + pub ipv6_endpoint_type: ::core::option::Option<::prost::alloc::string::String>, /// [Output Only] Type of the resource. Always compute#address for addresses. #[prost(string, optional, tag="3292052")] pub kind: ::core::option::Option<::prost::alloc::string::String>, @@ -683,6 +687,30 @@ pub mod address { } } } + /// The endpoint type of this address, which should be VM or NETLB. This is used for deciding which type of endpoint this address can be used after the external IPv6 address reservation. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Ipv6EndpointType { + /// A value indicating that the enum field is not set. + UndefinedIpv6EndpointType = 0, + /// Reserved IPv6 address can be used on network load balancer. + Netlb = 74173363, + /// Reserved IPv6 address can be used on VM. + Vm = 2743, + } + impl Ipv6EndpointType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Ipv6EndpointType::UndefinedIpv6EndpointType => "UNDEFINED_IPV6_ENDPOINT_TYPE", + Ipv6EndpointType::Netlb => "NETLB", + Ipv6EndpointType::Vm => "VM", + } + } + } /// This signifies the networking tier used for configuring this address and can only take the following values: PREMIUM or STANDARD. Internal IP addresses are always Premium Tier; global external IP addresses are always Premium Tier; regional external IP addresses can be either Standard or Premium Tier. If this field is not specified, it is assumed to be PREMIUM. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] @@ -3120,7 +3148,7 @@ pub struct BackendService { /// The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. #[prost(string, optional, tag="232872494")] pub network: ::core::option::Option<::prost::alloc::string::String>, - /// Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. + /// Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. #[prost(message, optional, tag="354625086")] pub outlier_detection: ::core::option::Option, /// Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. @@ -6601,6 +6629,8 @@ pub struct ErrorDetails { pub help: ::core::option::Option, #[prost(message, optional, tag="404537155")] pub localized_message: ::core::option::Option, + #[prost(message, optional, tag="93923861")] + pub quota_info: ::core::option::Option, } /// Describes the cause of the error with structured details. Example of an error when contacting the "pubsub.googleapis.com" API when it is not enabled: { "reason": "API_DISABLED" "domain": "googleapis.com" "metadata": { "resource": "projects/123", "service": "pubsub.googleapis.com" } } This response indicates that the pubsub.googleapis.com API is not enabled. Example of an error that is returned when attempting to create a Spanner instance in a region that is out of stock: { "reason": "STOCKOUT" "domain": "spanner.googleapis.com", "metadata": { "availableRegions": "us-central1,us-east2" } } #[derive(Clone, PartialEq, ::prost::Message)] @@ -7361,6 +7391,7 @@ pub struct ForwardingRule { /// This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. #[prost(string, optional, tag="307827694")] pub subnetwork: ::core::option::Option<::prost::alloc::string::String>, + /// The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. For more information, see the "Target" column in [Port specifications](). For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. #[prost(string, optional, tag="192835985")] pub target: ::core::option::Option<::prost::alloc::string::String>, } @@ -7600,30 +7631,30 @@ pub struct GrpcHealthCheck { /// The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII. #[prost(string, optional, tag="136533078")] pub grpc_service_name: ::core::option::Option<::prost::alloc::string::String>, - /// The port number for the health check request. Must be specified if port_name and port_specification are not set or if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535. + /// The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535. #[prost(int32, optional, tag="3446913")] pub port: ::core::option::Option, - /// Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence. The port_name should conform to RFC1035. + /// Not supported. #[prost(string, optional, tag="41534345")] pub port_name: ::core::option::Option<::prost::alloc::string::String>, - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, gRPC health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. /// Check the PortSpecification enum for the list of possible values. #[prost(string, optional, tag="51590597")] pub port_specification: ::core::option::Option<::prost::alloc::string::String>, } /// Nested message and enum types in `GRPCHealthCheck`. pub mod grpc_health_check { - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, gRPC health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PortSpecification { /// A value indicating that the enum field is not set. UndefinedPortSpecification = 0, - /// The port number in port is used for health checking. + /// The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. UseFixedPort = 190235748, - /// The portName is used for health checking. + /// Not supported. UseNamedPort = 349300671, - /// For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. + /// For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. UseServingPort = 362637516, } impl PortSpecification { @@ -9401,16 +9432,16 @@ pub mod guest_os_feature { /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct Http2HealthCheck { - /// The value of the host header in the HTTP/2 health check request. If left empty (default value), the IP on behalf of which this health check is performed will be used. + /// The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: #[prost(string, optional, tag="3208616")] pub host: ::core::option::Option<::prost::alloc::string::String>, - /// The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535. + /// The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535. #[prost(int32, optional, tag="3446913")] pub port: ::core::option::Option, - /// Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence. + /// Not supported. #[prost(string, optional, tag="41534345")] pub port_name: ::core::option::Option<::prost::alloc::string::String>, - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, HTTP2 health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. /// Check the PortSpecification enum for the list of possible values. #[prost(string, optional, tag="51590597")] pub port_specification: ::core::option::Option<::prost::alloc::string::String>, @@ -9421,23 +9452,23 @@ pub struct Http2HealthCheck { /// The request path of the HTTP/2 health check request. The default value is /. #[prost(string, optional, tag="229403605")] pub request_path: ::core::option::Option<::prost::alloc::string::String>, - /// The string to match anywhere in the first 1024 bytes of the response body. If left empty (the default value), the status code determines health. The response data can only be ASCII. + /// Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: #[prost(string, optional, tag="196547649")] pub response: ::core::option::Option<::prost::alloc::string::String>, } /// Nested message and enum types in `HTTP2HealthCheck`. pub mod http2_health_check { - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, HTTP2 health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PortSpecification { /// A value indicating that the enum field is not set. UndefinedPortSpecification = 0, - /// The port number in port is used for health checking. + /// The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. UseFixedPort = 190235748, - /// The portName is used for health checking. + /// Not supported. UseNamedPort = 349300671, - /// For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. + /// For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. UseServingPort = 362637516, } impl PortSpecification { @@ -9480,16 +9511,16 @@ pub mod http2_health_check { /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct HttpHealthCheck { - /// The value of the host header in the HTTP health check request. If left empty (default value), the IP on behalf of which this health check is performed will be used. + /// The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: #[prost(string, optional, tag="3208616")] pub host: ::core::option::Option<::prost::alloc::string::String>, - /// The TCP port number for the health check request. The default value is 80. Valid values are 1 through 65535. + /// The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535. #[prost(int32, optional, tag="3446913")] pub port: ::core::option::Option, - /// Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence. + /// Not supported. #[prost(string, optional, tag="41534345")] pub port_name: ::core::option::Option<::prost::alloc::string::String>, - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, HTTP health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. /// Check the PortSpecification enum for the list of possible values. #[prost(string, optional, tag="51590597")] pub port_specification: ::core::option::Option<::prost::alloc::string::String>, @@ -9500,23 +9531,23 @@ pub struct HttpHealthCheck { /// The request path of the HTTP health check request. The default value is /. #[prost(string, optional, tag="229403605")] pub request_path: ::core::option::Option<::prost::alloc::string::String>, - /// The string to match anywhere in the first 1024 bytes of the response body. If left empty (the default value), the status code determines health. The response data can only be ASCII. + /// Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: #[prost(string, optional, tag="196547649")] pub response: ::core::option::Option<::prost::alloc::string::String>, } /// Nested message and enum types in `HTTPHealthCheck`. pub mod http_health_check { - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, HTTP health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PortSpecification { /// A value indicating that the enum field is not set. UndefinedPortSpecification = 0, - /// The port number in port is used for health checking. + /// The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. UseFixedPort = 190235748, - /// The portName is used for health checking. + /// Not supported. UseNamedPort = 349300671, - /// For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. + /// For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. UseServingPort = 362637516, } impl PortSpecification { @@ -9559,16 +9590,16 @@ pub mod http_health_check { /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct HttpsHealthCheck { - /// The value of the host header in the HTTPS health check request. If left empty (default value), the IP on behalf of which this health check is performed will be used. + /// The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: #[prost(string, optional, tag="3208616")] pub host: ::core::option::Option<::prost::alloc::string::String>, - /// The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535. + /// The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535. #[prost(int32, optional, tag="3446913")] pub port: ::core::option::Option, - /// Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence. + /// Not supported. #[prost(string, optional, tag="41534345")] pub port_name: ::core::option::Option<::prost::alloc::string::String>, - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, HTTPS health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. /// Check the PortSpecification enum for the list of possible values. #[prost(string, optional, tag="51590597")] pub port_specification: ::core::option::Option<::prost::alloc::string::String>, @@ -9579,23 +9610,23 @@ pub struct HttpsHealthCheck { /// The request path of the HTTPS health check request. The default value is /. #[prost(string, optional, tag="229403605")] pub request_path: ::core::option::Option<::prost::alloc::string::String>, - /// The string to match anywhere in the first 1024 bytes of the response body. If left empty (the default value), the status code determines health. The response data can only be ASCII. + /// Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: #[prost(string, optional, tag="196547649")] pub response: ::core::option::Option<::prost::alloc::string::String>, } /// Nested message and enum types in `HTTPSHealthCheck`. pub mod https_health_check { - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, HTTPS health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PortSpecification { /// A value indicating that the enum field is not set. UndefinedPortSpecification = 0, - /// The port number in port is used for health checking. + /// The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. UseFixedPort = 190235748, - /// The portName is used for health checking. + /// Not supported. UseNamedPort = 349300671, - /// For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. + /// For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. UseServingPort = 362637516, } impl PortSpecification { @@ -11698,6 +11729,9 @@ pub struct Instance { /// Resource policies applied to this instance. #[prost(string, repeated, tag="22220385")] pub resource_policies: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// [Output Only] Specifies values set for instance attributes as compared to the values requested by user in the corresponding input only field. + #[prost(message, optional, tag="249429315")] + pub resource_status: ::core::option::Option, /// [Output Only] Reserved for future use. #[prost(bool, optional, tag="480964267")] pub satisfies_pzs: ::core::option::Option, @@ -12019,6 +12053,10 @@ pub struct InstanceGroupManager { /// [Output Only] The resource type, which is always compute#instanceGroupManager for managed instance groups. #[prost(string, optional, tag="3292052")] pub kind: ::core::option::Option<::prost::alloc::string::String>, + /// Pagination behavior of the listManagedInstances API method for this managed instance group. + /// Check the ListManagedInstancesResults enum for the list of possible values. + #[prost(string, optional, tag="296047156")] + pub list_managed_instances_results: ::core::option::Option<::prost::alloc::string::String>, /// The name of the managed instance group. The name must be 1-63 characters long, and comply with RFC1035. #[prost(string, optional, tag="3373707")] pub name: ::core::option::Option<::prost::alloc::string::String>, @@ -12053,6 +12091,33 @@ pub struct InstanceGroupManager { #[prost(string, optional, tag="3744684")] pub zone: ::core::option::Option<::prost::alloc::string::String>, } +/// Nested message and enum types in `InstanceGroupManager`. +pub mod instance_group_manager { + /// Pagination behavior of the listManagedInstances API method for this managed instance group. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum ListManagedInstancesResults { + /// A value indicating that the enum field is not set. + UndefinedListManagedInstancesResults = 0, + /// (Default) Pagination is disabled for the group's listManagedInstances API method. maxResults and pageToken query parameters are ignored and all instances are returned in a single response. + Pageless = 32183464, + /// Pagination is enabled for the group's listManagedInstances API method. maxResults and pageToken query parameters are respected. + Paginated = 40190637, + } + impl ListManagedInstancesResults { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ListManagedInstancesResults::UndefinedListManagedInstancesResults => "UNDEFINED_LIST_MANAGED_INSTANCES_RESULTS", + ListManagedInstancesResults::Pageless => "PAGELESS", + ListManagedInstancesResults::Paginated => "PAGINATED", + } + } + } +} /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct InstanceGroupManagerActionsSummary { @@ -17869,6 +17934,8 @@ pub struct NetworkEndpointGroup { /// Check the NetworkEndpointType enum for the list of possible values. #[prost(string, optional, tag="118301523")] pub network_endpoint_type: ::core::option::Option<::prost::alloc::string::String>, + #[prost(message, optional, tag="71937481")] + pub psc_data: ::core::option::Option, /// The target service url used to set up private service connection to a Google API or a PSC Producer Service Attachment. An example value is: "asia-northeast3-cloudkms.googleapis.com" #[prost(string, optional, tag="269132134")] pub psc_target_service: ::core::option::Option<::prost::alloc::string::String>, @@ -18013,6 +18080,58 @@ pub struct NetworkEndpointGroupList { #[prost(message, optional, tag="50704284")] pub warning: ::core::option::Option, } +/// All data that is specifically relevant to only network endpoint groups of type PRIVATE_SERVICE_CONNECT. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NetworkEndpointGroupPscData { + /// [Output Only] Address allocated from given subnetwork for PSC. This IP address acts as a VIP for a PSC NEG, allowing it to act as an endpoint in L7 PSC-XLB. + #[prost(string, optional, tag="452646572")] + pub consumer_psc_address: ::core::option::Option<::prost::alloc::string::String>, + /// [Output Only] The PSC connection id of the PSC Network Endpoint Group Consumer. + #[prost(uint64, optional, tag="292082397")] + pub psc_connection_id: ::core::option::Option, + /// [Output Only] The connection status of the PSC Forwarding Rule. + /// Check the PscConnectionStatus enum for the list of possible values. + #[prost(string, optional, tag="184149172")] + pub psc_connection_status: ::core::option::Option<::prost::alloc::string::String>, +} +/// Nested message and enum types in `NetworkEndpointGroupPscData`. +pub mod network_endpoint_group_psc_data { + /// [Output Only] The connection status of the PSC Forwarding Rule. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum PscConnectionStatus { + /// A value indicating that the enum field is not set. + UndefinedPscConnectionStatus = 0, + /// The connection has been accepted by the producer. + Accepted = 246714279, + /// The connection has been closed by the producer and will not serve traffic going forward. + Closed = 380163436, + /// The connection has been accepted by the producer, but the producer needs to take further action before the forwarding rule can serve traffic. + NeedsAttention = 344491452, + /// The connection is pending acceptance by the producer. + Pending = 35394935, + /// The connection has been rejected by the producer. + Rejected = 174130302, + StatusUnspecified = 42133066, + } + impl PscConnectionStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + PscConnectionStatus::UndefinedPscConnectionStatus => "UNDEFINED_PSC_CONNECTION_STATUS", + PscConnectionStatus::Accepted => "ACCEPTED", + PscConnectionStatus::Closed => "CLOSED", + PscConnectionStatus::NeedsAttention => "NEEDS_ATTENTION", + PscConnectionStatus::Pending => "PENDING", + PscConnectionStatus::Rejected => "REJECTED", + PscConnectionStatus::StatusUnspecified => "STATUS_UNSPECIFIED", + } + } + } +} /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct NetworkEndpointGroupsAttachEndpointsRequest { @@ -19376,16 +19495,16 @@ pub struct OutlierDetection { /// The base time that a host is ejected for. The real ejection time is equal to the base ejection time multiplied by the number of times the host has been ejected. Defaults to 30000ms or 30s. #[prost(message, optional, tag="80997255")] pub base_ejection_time: ::core::option::Option, - /// Number of errors before a host is ejected from the connection pool. When the backend host is accessed over HTTP, a 5xx return code qualifies as an error. Defaults to 5. + /// Number of errors before a host is ejected from the connection pool. When the backend host is accessed over HTTP, a 5xx return code qualifies as an error. Defaults to 5. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. #[prost(int32, optional, tag="387193248")] pub consecutive_errors: ::core::option::Option, - /// The number of consecutive gateway failures (502, 503, 504 status or connection errors that are mapped to one of those status codes) before a consecutive gateway failure ejection occurs. Defaults to 3. + /// The number of consecutive gateway failures (502, 503, 504 status or connection errors that are mapped to one of those status codes) before a consecutive gateway failure ejection occurs. Defaults to 3. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. #[prost(int32, optional, tag="417504250")] pub consecutive_gateway_failure: ::core::option::Option, - /// The percentage chance that a host will be actually ejected when an outlier status is detected through consecutive 5xx. This setting can be used to disable ejection or to ramp it up slowly. Defaults to 0. + /// The percentage chance that a host will be actually ejected when an outlier status is detected through consecutive 5xx. This setting can be used to disable ejection or to ramp it up slowly. Defaults to 0. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. #[prost(int32, optional, tag="213133760")] pub enforcing_consecutive_errors: ::core::option::Option, - /// The percentage chance that a host will be actually ejected when an outlier status is detected through consecutive gateway failures. This setting can be used to disable ejection or to ramp it up slowly. Defaults to 100. + /// The percentage chance that a host will be actually ejected when an outlier status is detected through consecutive gateway failures. This setting can be used to disable ejection or to ramp it up slowly. Defaults to 100. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. #[prost(int32, optional, tag="394440666")] pub enforcing_consecutive_gateway_failure: ::core::option::Option, /// The percentage chance that a host will be actually ejected when an outlier status is detected through success rate statistics. This setting can be used to disable ejection or to ramp it up slowly. Defaults to 100. @@ -21366,6 +21485,7 @@ pub mod quota { SslCertificates = 378372399, StaticAddresses = 93624049, StaticByoipAddresses = 275809649, + StaticExternalIpv6AddressRanges = 472346774, Subnetworks = 421330469, T2aCpus = 522170599, T2dCpus = 71187140, @@ -21507,6 +21627,7 @@ pub mod quota { Metric::SslCertificates => "SSL_CERTIFICATES", Metric::StaticAddresses => "STATIC_ADDRESSES", Metric::StaticByoipAddresses => "STATIC_BYOIP_ADDRESSES", + Metric::StaticExternalIpv6AddressRanges => "STATIC_EXTERNAL_IPV6_ADDRESS_RANGES", Metric::Subnetworks => "SUBNETWORKS", Metric::T2aCpus => "T2A_CPUS", Metric::T2dCpus => "T2D_CPUS", @@ -21525,6 +21646,22 @@ pub mod quota { } } } +/// Additional details for quota exceeded error for resource quota. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QuotaExceededInfo { + /// The map holding related quota dimensions. + #[prost(map="string, string", tag="414334925")] + pub dimensions: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Current effective quota limit. The limit's unit depends on the quota type or metric. + #[prost(double, optional, tag="102976443")] + pub limit: ::core::option::Option, + /// The name of the quota limit. + #[prost(string, optional, tag="398197903")] + pub limit_name: ::core::option::Option<::prost::alloc::string::String>, + /// The Compute Engine quota metric name. + #[prost(string, optional, tag="409881530")] + pub metric_name: ::core::option::Option<::prost::alloc::string::String>, +} /// The parameters of the raw disk image. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RawDisk { @@ -23118,6 +23255,13 @@ pub mod resource_policy_weekly_cycle_day_of_week { } } } +/// Contains output only fields. Use this sub-message for actual values set on Instance attributes as compared to the value requested by the user (intent) in their instance CRUD calls. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResourceStatus { + /// [Output Only] An opaque ID of the host on which the VM is running. + #[prost(string, optional, tag="464370704")] + pub physical_host: ::core::option::Option<::prost::alloc::string::String>, +} /// A request message for Instances.Resume. See the method description for details. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResumeInstanceRequest { @@ -23351,6 +23495,9 @@ pub struct Router { /// [Output Only] Type of resource. Always compute#router for routers. #[prost(string, optional, tag="3292052")] pub kind: ::core::option::Option<::prost::alloc::string::String>, + /// Keys used for MD5 authentication. + #[prost(message, repeated, tag="71063322")] + pub md5_authentication_keys: ::prost::alloc::vec::Vec, /// Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `\[a-z]([-a-z0-9]*[a-z0-9\])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. #[prost(string, optional, tag="3373707")] pub name: ::core::option::Option<::prost::alloc::string::String>, @@ -23509,6 +23656,9 @@ pub struct RouterBgpPeer { /// Check the ManagementType enum for the list of possible values. #[prost(string, optional, tag="173703606")] pub management_type: ::core::option::Option<::prost::alloc::string::String>, + /// Present if MD5 authentication is enabled for the peering. Must be the name of one of the entries in the Router.md5_authentication_keys. The field must comply with RFC1035. + #[prost(string, optional, tag="281075345")] + pub md5_authentication_key_name: ::core::option::Option<::prost::alloc::string::String>, /// Name of this BGP peer. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `\[a-z]([-a-z0-9]*[a-z0-9\])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. #[prost(string, optional, tag="3373707")] pub name: ::core::option::Option<::prost::alloc::string::String>, @@ -23739,6 +23889,16 @@ pub struct RouterList { #[prost(message, optional, tag="50704284")] pub warning: ::core::option::Option, } +/// +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RouterMd5AuthenticationKey { + /// [Input only] Value of the key. For patch and update calls, it can be skipped to copy the value from the previous configuration. This is allowed if the key with the same name existed before the operation. Maximum length is 80 characters. Can only contain printable ASCII characters. + #[prost(string, optional, tag="106079")] + pub key: ::core::option::Option<::prost::alloc::string::String>, + /// Name used to identify the key. Must be unique within a router. Must be referenced by at least one bgpPeer. Must comply with RFC1035. + #[prost(string, optional, tag="3373707")] + pub name: ::core::option::Option<::prost::alloc::string::String>, +} /// Represents a Nat resource. It enables the VMs within the specified subnetworks to access Internet without external IP addresses. It specifies a list of subnetworks (and the ranges within) that want to use NAT. Customers can also provide the external IPs that would be used for NAT. GCP would auto-allocate ephemeral IPs if no external IPs are provided. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RouterNat { @@ -24013,12 +24173,21 @@ pub struct RouterStatusBgpPeerStatus { pub advertised_routes: ::prost::alloc::vec::Vec, #[prost(message, optional, tag="395631729")] pub bfd_status: ::core::option::Option, + /// Enable IPv6 traffic over BGP Peer. If not specified, it is disabled by default. + #[prost(bool, optional, tag="181467939")] + pub enable_ipv6: ::core::option::Option, /// IP address of the local BGP interface. #[prost(string, optional, tag="406272220")] pub ip_address: ::core::option::Option<::prost::alloc::string::String>, + /// IPv6 address of the local BGP interface. + #[prost(string, optional, tag="27968211")] + pub ipv6_nexthop_address: ::core::option::Option<::prost::alloc::string::String>, /// URL of the VPN tunnel that this BGP peer controls. #[prost(string, optional, tag="352296953")] pub linked_vpn_tunnel: ::core::option::Option<::prost::alloc::string::String>, + /// Informs whether MD5 authentication is enabled on this BGP peer. + #[prost(bool, optional, tag="451152075")] + pub md5_auth_enabled: ::core::option::Option, /// Name of this BGP peer. Unique within the Routers resource. #[prost(string, optional, tag="3373707")] pub name: ::core::option::Option<::prost::alloc::string::String>, @@ -24028,6 +24197,9 @@ pub struct RouterStatusBgpPeerStatus { /// IP address of the remote BGP interface. #[prost(string, optional, tag="207735769")] pub peer_ip_address: ::core::option::Option<::prost::alloc::string::String>, + /// IPv6 address of the remote BGP interface. + #[prost(string, optional, tag="491486608")] + pub peer_ipv6_nexthop_address: ::core::option::Option<::prost::alloc::string::String>, /// [Output only] URI of the VM instance that is used as third-party router appliances such as Next Gen Firewalls, Virtual Routers, or Router Appliances. The VM instance is the peer side of the BGP session. #[prost(string, optional, tag="468312989")] pub router_appliance_instance: ::core::option::Option<::prost::alloc::string::String>, @@ -24038,6 +24210,10 @@ pub struct RouterStatusBgpPeerStatus { /// Check the Status enum for the list of possible values. #[prost(string, optional, tag="181260274")] pub status: ::core::option::Option<::prost::alloc::string::String>, + /// Indicates why particular status was returned. + /// Check the StatusReason enum for the list of possible values. + #[prost(string, optional, tag="342706993")] + pub status_reason: ::core::option::Option<::prost::alloc::string::String>, /// Time this session has been up. Format: 14 years, 51 weeks, 6 days, 23 hours, 59 minutes, 59 seconds #[prost(string, optional, tag="235379688")] pub uptime: ::core::option::Option<::prost::alloc::string::String>, @@ -24071,6 +24247,29 @@ pub mod router_status_bgp_peer_status { } } } + /// Indicates why particular status was returned. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum StatusReason { + /// A value indicating that the enum field is not set. + UndefinedStatusReason = 0, + /// Indicates internal problems with configuration of MD5 authentication. This particular reason can only be returned when md5AuthEnabled is true and status is DOWN. + Md5AuthInternalProblem = 140462259, + Unspecified = 394331913, + } + impl StatusReason { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + StatusReason::UndefinedStatusReason => "UNDEFINED_STATUS_REASON", + StatusReason::Md5AuthInternalProblem => "MD5_AUTH_INTERNAL_PROBLEM", + StatusReason::Unspecified => "STATUS_REASON_UNSPECIFIED", + } + } + } } /// Status of a NAT contained in this router. #[derive(Clone, PartialEq, ::prost::Message)] @@ -24216,13 +24415,13 @@ pub mod rule { /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct SslHealthCheck { - /// The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535. + /// The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535. #[prost(int32, optional, tag="3446913")] pub port: ::core::option::Option, - /// Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence. + /// Not supported. #[prost(string, optional, tag="41534345")] pub port_name: ::core::option::Option<::prost::alloc::string::String>, - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. /// Check the PortSpecification enum for the list of possible values. #[prost(string, optional, tag="51590597")] pub port_specification: ::core::option::Option<::prost::alloc::string::String>, @@ -24230,26 +24429,26 @@ pub struct SslHealthCheck { /// Check the ProxyHeader enum for the list of possible values. #[prost(string, optional, tag="160374142")] pub proxy_header: ::core::option::Option<::prost::alloc::string::String>, - /// The application data to send once the SSL connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII. + /// Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake. #[prost(string, optional, tag="21951119")] pub request: ::core::option::Option<::prost::alloc::string::String>, - /// The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII. + /// Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: #[prost(string, optional, tag="196547649")] pub response: ::core::option::Option<::prost::alloc::string::String>, } /// Nested message and enum types in `SSLHealthCheck`. pub mod ssl_health_check { - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PortSpecification { /// A value indicating that the enum field is not set. UndefinedPortSpecification = 0, - /// The port number in port is used for health checking. + /// The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. UseFixedPort = 190235748, - /// The portName is used for health checking. + /// Not supported. UseNamedPort = 349300671, - /// For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. + /// For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. UseServingPort = 362637516, } impl PortSpecification { @@ -24808,7 +25007,7 @@ pub struct SecurityPolicy { /// [Output Only] URL of the region where the regional security policy resides. This field is not applicable to global security policies. #[prost(string, optional, tag="138946292")] pub region: ::core::option::Option<::prost::alloc::string::String>, - /// A list of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added. + /// A list of rules that belong to this policy. There must always be a default rule which is a rule with priority 2147483647 and match all condition (for the match condition this means match "*" for srcIpRanges and for the networkMatch condition every field must be either match "*" or not set). If no rules are provided when creating a security policy, a default rule with action "allow" will be added. #[prost(message, repeated, tag="108873975")] pub rules: ::prost::alloc::vec::Vec, /// [Output Only] Server-defined URL for the resource. @@ -25128,7 +25327,7 @@ pub struct SecurityPolicyRuleRateLimitOptions { /// Action to take for requests that are under the configured rate limit threshold. Valid option is "allow" only. #[prost(string, optional, tag="517612367")] pub conform_action: ::core::option::Option<::prost::alloc::string::String>, - /// Determines the key to enforce the rate_limit_threshold on. Possible values are: - ALL: A single rate limit threshold is applied to all the requests matching this rule. This is the default value if this field 'enforce_on_key' is not configured. - IP: The source IP address of the request is the key. Each IP has this limit enforced separately. - HTTP_HEADER: The value of the HTTP header whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to ALL. - XFF_IP: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key defaults to the source IP address of the request i.e. key type IP. - HTTP_COOKIE: The value of the HTTP cookie whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to ALL. + /// Determines the key to enforce the rate_limit_threshold on. Possible values are: - ALL: A single rate limit threshold is applied to all the requests matching this rule. This is the default value if this field 'enforce_on_key' is not configured. - IP: The source IP address of the request is the key. Each IP has this limit enforced separately. - HTTP_HEADER: The value of the HTTP header whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to ALL. - XFF_IP: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key defaults to the source IP address of the request i.e. key type IP. - HTTP_COOKIE: The value of the HTTP cookie whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to ALL. - HTTP_PATH: The URL path of the HTTP request. The key value is truncated to the first 128 bytes. - SNI: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to ALL on a HTTP session. - REGION_CODE: The country/region from which the request originates. /// Check the EnforceOnKey enum for the list of possible values. #[prost(string, optional, tag="416648956")] pub enforce_on_key: ::core::option::Option<::prost::alloc::string::String>, @@ -25147,7 +25346,7 @@ pub struct SecurityPolicyRuleRateLimitOptions { } /// Nested message and enum types in `SecurityPolicyRuleRateLimitOptions`. pub mod security_policy_rule_rate_limit_options { - /// Determines the key to enforce the rate_limit_threshold on. Possible values are: - ALL: A single rate limit threshold is applied to all the requests matching this rule. This is the default value if this field 'enforce_on_key' is not configured. - IP: The source IP address of the request is the key. Each IP has this limit enforced separately. - HTTP_HEADER: The value of the HTTP header whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to ALL. - XFF_IP: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key defaults to the source IP address of the request i.e. key type IP. - HTTP_COOKIE: The value of the HTTP cookie whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to ALL. + /// Determines the key to enforce the rate_limit_threshold on. Possible values are: - ALL: A single rate limit threshold is applied to all the requests matching this rule. This is the default value if this field 'enforce_on_key' is not configured. - IP: The source IP address of the request is the key. Each IP has this limit enforced separately. - HTTP_HEADER: The value of the HTTP header whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to ALL. - XFF_IP: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key defaults to the source IP address of the request i.e. key type IP. - HTTP_COOKIE: The value of the HTTP cookie whose name is configured under "enforce_on_key_name". The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to ALL. - HTTP_PATH: The URL path of the HTTP request. The key value is truncated to the first 128 bytes. - SNI: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to ALL on a HTTP session. - REGION_CODE: The country/region from which the request originates. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum EnforceOnKey { @@ -25156,7 +25355,10 @@ pub mod security_policy_rule_rate_limit_options { All = 64897, HttpCookie = 494981627, HttpHeader = 91597348, + HttpPath = 311503228, Ip = 2343, + RegionCode = 79559768, + Sni = 82254, XffIp = 438707118, } impl EnforceOnKey { @@ -25170,7 +25372,10 @@ pub mod security_policy_rule_rate_limit_options { EnforceOnKey::All => "ALL", EnforceOnKey::HttpCookie => "HTTP_COOKIE", EnforceOnKey::HttpHeader => "HTTP_HEADER", + EnforceOnKey::HttpPath => "HTTP_PATH", EnforceOnKey::Ip => "IP", + EnforceOnKey::RegionCode => "REGION_CODE", + EnforceOnKey::Sni => "SNI", EnforceOnKey::XffIp => "XFF_IP", } } @@ -28190,13 +28395,13 @@ pub struct SwitchToCustomModeNetworkRequest { /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct TcpHealthCheck { - /// The TCP port number for the health check request. The default value is 80. Valid values are 1 through 65535. + /// The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535. #[prost(int32, optional, tag="3446913")] pub port: ::core::option::Option, - /// Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence. + /// Not supported. #[prost(string, optional, tag="41534345")] pub port_name: ::core::option::Option<::prost::alloc::string::String>, - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, TCP health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. /// Check the PortSpecification enum for the list of possible values. #[prost(string, optional, tag="51590597")] pub port_specification: ::core::option::Option<::prost::alloc::string::String>, @@ -28204,26 +28409,26 @@ pub struct TcpHealthCheck { /// Check the ProxyHeader enum for the list of possible values. #[prost(string, optional, tag="160374142")] pub proxy_header: ::core::option::Option<::prost::alloc::string::String>, - /// The application data to send once the TCP connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII. + /// Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection. #[prost(string, optional, tag="21951119")] pub request: ::core::option::Option<::prost::alloc::string::String>, - /// The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII. + /// Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: #[prost(string, optional, tag="196547649")] pub response: ::core::option::Option<::prost::alloc::string::String>, } /// Nested message and enum types in `TCPHealthCheck`. pub mod tcp_health_check { - /// Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, TCP health check follows behavior specified in port and portName fields. + /// Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PortSpecification { /// A value indicating that the enum field is not set. UndefinedPortSpecification = 0, - /// The port number in port is used for health checking. + /// The port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends. UseFixedPort = 190235748, - /// The portName is used for health checking. + /// Not supported. UseNamedPort = 349300671, - /// For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. + /// For network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports. UseServingPort = 362637516, } impl PortSpecification { @@ -45154,7 +45359,7 @@ pub mod region_security_policies_client { ); self.inner.unary(request.into_request(), path, codec).await } - /// Patches the specified policy with the data included in the request. + /// Patches the specified policy with the data included in the request. To clear fields in the rule, leave the fields empty and specify them in the updateMask. This cannot be used to be update the rules in the policy. Please use the per rule methods like addRule, patchRule, and removeRule instead. pub async fn patch( &mut self, request: impl tonic::IntoRequest, @@ -47574,7 +47779,7 @@ pub mod security_policies_client { ); self.inner.unary(request.into_request(), path, codec).await } - /// Patches the specified policy with the data included in the request. This cannot be used to be update the rules in the policy. Please use the per rule methods like addRule, patchRule, and removeRule instead. + /// Patches the specified policy with the data included in the request. To clear fields in the rule, leave the fields empty and specify them in the updateMask. This cannot be used to be update the rules in the policy. Please use the per rule methods like addRule, patchRule, and removeRule instead. pub async fn patch( &mut self, request: impl tonic::IntoRequest, diff --git a/gcloud-sdk/genproto/google.cloud.contentwarehouse.v1.rs b/gcloud-sdk/genproto/google.cloud.contentwarehouse.v1.rs index 538bc896e..af662b1c1 100644 --- a/gcloud-sdk/genproto/google.cloud.contentwarehouse.v1.rs +++ b/gcloud-sdk/genproto/google.cloud.contentwarehouse.v1.rs @@ -1090,8 +1090,10 @@ pub mod document_schema_service_client { } /// Updates a Document Schema. Returns INVALID_ARGUMENT if the name of the /// Document Schema is non-empty and does not equal the existing name. - /// Supports only appending new properties and updating existing properties - /// will result into INVALID_ARGUMENT. + /// Supports only appending new properties, adding new ENUM possible values, + /// and updating the [EnumTypeOptions.validation_check_disabled][google.cloud.contentwarehouse.v1.EnumTypeOptions.validation_check_disabled] flag for + /// ENUM possible values. Updating existing properties will result into + /// INVALID_ARGUMENT. pub async fn update_document_schema( &mut self, request: impl tonic::IntoRequest, @@ -1133,7 +1135,8 @@ pub mod document_schema_service_client { self.inner.unary(request.into_request(), path, codec).await } /// Deletes a document schema. Returns NOT_FOUND if the document schema does - /// not exist. + /// not exist. Returns BAD_REQUEST if the document schema has documents + /// depending on it. pub async fn delete_document_schema( &mut self, request: impl tonic::IntoRequest, @@ -1659,7 +1662,9 @@ pub struct SearchDocumentsRequest { /// Optional. Controls if the search document request requires the return of a total size /// of matched documents. See \[SearchDocumentsResponse.total_size][google.cloud.contentwarehouse.v1.SearchDocumentsResponse.total_size\]. /// - /// Enabling this flag may adversely impact performance. + /// Enabling this flag may adversely impact performance. Hint: If this is + /// used with pagination, set this flag on the initial query but set this + /// to false on subsequent page calls (keep the total count locally). /// /// Defaults to false. #[prost(bool, tag="10")] @@ -2091,7 +2096,10 @@ pub struct SearchDocumentsResponse { pub next_page_token: ::prost::alloc::string::String, /// The total number of matched documents which is available only if the client /// set \[SearchDocumentsRequest.require_total_size][google.cloud.contentwarehouse.v1.SearchDocumentsRequest.require_total_size\] to `true`. Otherwise, the - /// value will be `-1`. + /// value will be `-1`. `total_size` will max at "100,000". If this + /// is returned, then it can be assumed that the count is equal to or greater + /// than 100,000. Typically a UI would handle this condition by displaying + /// "of many", for example: "Displaying 10 of many". #[prost(int32, tag="3")] pub total_size: i32, /// Additional information for the API invocation, such as the request tracking diff --git a/gcloud-sdk/genproto/google.cloud.dialogflow.cx.v3.rs b/gcloud-sdk/genproto/google.cloud.dialogflow.cx.v3.rs index f3f5acc25..77ef4b34a 100644 --- a/gcloud-sdk/genproto/google.cloud.dialogflow.cx.v3.rs +++ b/gcloud-sdk/genproto/google.cloud.dialogflow.cx.v3.rs @@ -9314,12 +9314,9 @@ pub mod security_settings { /// Retains data in interaction logging for the specified number of days. /// This does not apply to Cloud logging, which is owned by the user - not /// Dialogflow. - /// User must set a value lower than Dialogflow's default 365d TTL. Setting a - /// value higher than that has no effect. - /// A missing value or setting to 0 also means we use Dialogflow's default - /// TTL. - /// Note: Interaction logging is a limited access feature. Talk to your - /// Google representative to check availability for you. + /// User must set a value lower than Dialogflow's default 365d TTL (time to + /// live). Setting a value higher than that has no effect. A missing value or + /// setting to 0 also means we use Dialogflow's default TTL. #[prost(int32, tag="6")] RetentionWindowDays(i32), } diff --git a/gcloud-sdk/genproto/google.cloud.dialogflow.v2beta1.rs b/gcloud-sdk/genproto/google.cloud.dialogflow.v2beta1.rs index a5a07a508..1932718c5 100644 --- a/gcloud-sdk/genproto/google.cloud.dialogflow.v2beta1.rs +++ b/gcloud-sdk/genproto/google.cloud.dialogflow.v2beta1.rs @@ -842,10 +842,12 @@ pub struct InputAudioConfig { /// the same session do not necessarily need to specify the same language. #[prost(string, tag="3")] pub language_code: ::prost::alloc::string::String, - /// If `true`, Dialogflow returns \[SpeechWordInfo][google.cloud.dialogflow.v2beta1.SpeechWordInfo\] in - /// \[StreamingRecognitionResult][google.cloud.dialogflow.v2beta1.StreamingRecognitionResult\] with information about the recognized speech - /// words, e.g. start and end time offsets. If false or unspecified, Speech - /// doesn't return any word-level information. + /// If `true`, Dialogflow returns + /// \[SpeechWordInfo][google.cloud.dialogflow.v2beta1.SpeechWordInfo\] in + /// \[StreamingRecognitionResult][google.cloud.dialogflow.v2beta1.StreamingRecognitionResult\] + /// with information about the recognized speech words, e.g. start and end time + /// offsets. If false or unspecified, Speech doesn't return any word-level + /// information. #[prost(bool, tag="13")] pub enable_word_info: bool, /// A list of strings containing words and phrases that the speech @@ -881,7 +883,8 @@ pub struct InputAudioConfig { /// for more details. #[prost(string, tag="7")] pub model: ::prost::alloc::string::String, - /// Which variant of the [Speech model]\[google.cloud.dialogflow.v2beta1.InputAudioConfig.model\] to use. + /// Which variant of the [Speech + /// model]\[google.cloud.dialogflow.v2beta1.InputAudioConfig.model\] to use. #[prost(enumeration="SpeechModelVariant", tag="10")] pub model_variant: i32, /// If `false` (default), recognition does not cease until the @@ -896,7 +899,9 @@ pub struct InputAudioConfig { /// over StreamingDetectIntentRequest.single_utterance. #[prost(bool, tag="8")] pub single_utterance: bool, - /// Only used in \[Participants.AnalyzeContent][google.cloud.dialogflow.v2beta1.Participants.AnalyzeContent\] and + /// Only used in + /// \[Participants.AnalyzeContent][google.cloud.dialogflow.v2beta1.Participants.AnalyzeContent\] + /// and /// \[Participants.StreamingAnalyzeContent][google.cloud.dialogflow.v2beta1.Participants.StreamingAnalyzeContent\]. /// If `false` and recognition doesn't return any result, trigger /// `NO_SPEECH_RECOGNIZED` event to Dialogflow agent. @@ -916,9 +921,10 @@ pub struct VoiceSelectionParams { pub name: ::prost::alloc::string::String, /// Optional. The preferred gender of the voice. If not set, the service will /// choose a voice based on the other parameters such as language_code and - /// \[name][google.cloud.dialogflow.v2beta1.VoiceSelectionParams.name\]. Note that this is only a preference, not requirement. If a - /// voice of the appropriate gender is not available, the synthesizer should - /// substitute a voice with a different gender rather than failing the request. + /// \[name][google.cloud.dialogflow.v2beta1.VoiceSelectionParams.name\]. Note + /// that this is only a preference, not requirement. If a voice of the + /// appropriate gender is not available, the synthesizer should substitute a + /// voice with a different gender rather than failing the request. #[prost(enumeration="SsmlVoiceGender", tag="2")] pub ssml_gender: i32, } @@ -981,18 +987,30 @@ pub struct TelephonyDtmfEvents { #[prost(enumeration="TelephonyDtmf", repeated, tag="1")] pub dtmf_events: ::prost::alloc::vec::Vec, } -/// Configures speech transcription for \[ConversationProfile][google.cloud.dialogflow.v2beta1.ConversationProfile\]. +/// Configures speech transcription for +/// \[ConversationProfile][google.cloud.dialogflow.v2beta1.ConversationProfile\]. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SpeechToTextConfig { /// The speech model used in speech to text. /// `SPEECH_MODEL_VARIANT_UNSPECIFIED`, `USE_BEST_AVAILABLE` will be treated as - /// `USE_ENHANCED`. It can be overridden in \[AnalyzeContentRequest][google.cloud.dialogflow.v2beta1.AnalyzeContentRequest\] and - /// \[StreamingAnalyzeContentRequest][google.cloud.dialogflow.v2beta1.StreamingAnalyzeContentRequest\] request. - /// If enhanced model variant is specified and an enhanced - /// version of the specified model for the language does not exist, then it - /// would emit an error. + /// `USE_ENHANCED`. It can be overridden in + /// \[AnalyzeContentRequest][google.cloud.dialogflow.v2beta1.AnalyzeContentRequest\] + /// and + /// \[StreamingAnalyzeContentRequest][google.cloud.dialogflow.v2beta1.StreamingAnalyzeContentRequest\] + /// request. If enhanced model variant is specified and an enhanced version of + /// the specified model for the language does not exist, then it would emit an + /// error. #[prost(enumeration="SpeechModelVariant", tag="1")] pub speech_model_variant: i32, + /// Which Speech model to select. Select the model best suited to your domain + /// to get best results. If a model is not explicitly specified, then a default + /// model is used. + /// Refer to + /// [Cloud Speech API + /// documentation]() + /// for more details. + #[prost(string, tag="2")] + pub model: ::prost::alloc::string::String, } /// Audio encoding of the audio content sent in the conversational query request. /// Refer to the @@ -1055,7 +1073,8 @@ impl AudioEncoding { } } } -/// Variant of the specified [Speech model]\[google.cloud.dialogflow.v2beta1.InputAudioConfig.model\] to use. +/// Variant of the specified [Speech +/// model]\[google.cloud.dialogflow.v2beta1.InputAudioConfig.model\] to use. /// /// See the [Cloud Speech /// documentation]() @@ -1083,8 +1102,8 @@ pub enum SpeechModelVariant { /// Use an enhanced model variant: /// /// * If an enhanced variant does not exist for the given - /// \[model][google.cloud.dialogflow.v2beta1.InputAudioConfig.model\] and request language, Dialogflow falls - /// back to the standard variant. + /// \[model][google.cloud.dialogflow.v2beta1.InputAudioConfig.model\] and + /// request language, Dialogflow falls back to the standard variant. /// /// The [Cloud Speech /// documentation]() diff --git a/gcloud-sdk/genproto/google.cloud.run.v2.rs b/gcloud-sdk/genproto/google.cloud.run.v2.rs index eb75925ff..d2ebda458 100644 --- a/gcloud-sdk/genproto/google.cloud.run.v2.rs +++ b/gcloud-sdk/genproto/google.cloud.run.v2.rs @@ -213,6 +213,8 @@ pub mod condition { /// A task reached its retry limit and the last attempt failed due to the /// user container exiting with a non-zero exit code. NonZeroExitCode = 2, + /// The execution was cancelled by users. + Cancelled = 3, } impl ExecutionReason { /// String value of the enum field names used in the ProtoBuf definition. @@ -224,6 +226,7 @@ pub mod condition { ExecutionReason::Undefined => "EXECUTION_REASON_UNDEFINED", ExecutionReason::JobStatusServicePollingError => "JOB_STATUS_SERVICE_POLLING_ERROR", ExecutionReason::NonZeroExitCode => "NON_ZERO_EXIT_CODE", + ExecutionReason::Cancelled => "CANCELLED", } } } @@ -298,6 +301,25 @@ pub struct Container { /// Volume to mount into the container's filesystem. #[prost(message, repeated, tag="8")] pub volume_mounts: ::prost::alloc::vec::Vec, + /// Container's working directory. + /// If not specified, the container runtime's default will be used, which + /// might be configured in the container image. + #[prost(string, tag="9")] + pub working_dir: ::prost::alloc::string::String, + /// Periodic probe of container liveness. + /// Container will be restarted if the probe fails. + /// More info: + /// + #[prost(message, optional, tag="10")] + pub liveness_probe: ::core::option::Option, + /// Startup probe of application within the container. + /// All other probes are disabled if a startup probe is provided, until it + /// succeeds. Container will not be added to service endpoints if the probe + /// fails. + /// More info: + /// + #[prost(message, optional, tag="11")] + pub startup_probe: ::core::option::Option, } /// ResourceRequirements describes the compute resource requirements. #[derive(Clone, PartialEq, ::prost::Message)] @@ -432,7 +454,7 @@ pub struct SecretVolumeSource { #[prost(message, repeated, tag="2")] pub items: ::prost::alloc::vec::Vec, /// Integer representation of mode bits to use on created files by default. - /// Must be a value between 0000 and 0777 (octal), defaulting to 0644. + /// Must be a value between 0000 and 0777 (octal), defaulting to 0444. /// Directories within the path are not affected by this setting. /// /// Notes @@ -492,6 +514,79 @@ pub struct CloudSqlInstance { #[prost(string, repeated, tag="1")] pub instances: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } +/// Probe describes a health check to be performed against a container to +/// determine whether it is alive or ready to receive traffic. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Probe { + /// Number of seconds after the container has started before the probe is + /// initiated. + /// Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe + /// is 3600. Maximum value for startup probe is 240. + /// More info: + /// + #[prost(int32, tag="1")] + pub initial_delay_seconds: i32, + /// Number of seconds after which the probe times out. + /// Defaults to 1 second. Minimum value is 1. Maximum value is 3600. + /// Must be smaller than period_seconds. + /// More info: + /// + #[prost(int32, tag="2")] + pub timeout_seconds: i32, + /// How often (in seconds) to perform the probe. + /// Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe + /// is 3600. Maximum value for startup probe is 240. + /// Must be greater or equal than timeout_seconds. + #[prost(int32, tag="3")] + pub period_seconds: i32, + /// Minimum consecutive failures for the probe to be considered failed after + /// having succeeded. Defaults to 3. Minimum value is 1. + #[prost(int32, tag="4")] + pub failure_threshold: i32, + #[prost(oneof="probe::ProbeType", tags="5, 6")] + pub probe_type: ::core::option::Option, +} +/// Nested message and enum types in `Probe`. +pub mod probe { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ProbeType { + /// HTTPGet specifies the http request to perform. + /// Exactly one of HTTPGet or TCPSocket must be specified. + #[prost(message, tag="5")] + HttpGet(super::HttpGetAction), + /// TCPSocket specifies an action involving a TCP port. + /// Exactly one of HTTPGet or TCPSocket must be specified. + #[prost(message, tag="6")] + TcpSocket(super::TcpSocketAction), + } +} +/// HTTPGetAction describes an action based on HTTP Get requests. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HttpGetAction { + /// Path to access on the HTTP server. Defaults to '/'. + #[prost(string, tag="1")] + pub path: ::prost::alloc::string::String, + /// Custom headers to set in the request. HTTP allows repeated headers. + #[prost(message, repeated, tag="4")] + pub http_headers: ::prost::alloc::vec::Vec, +} +/// HTTPHeader describes a custom header to be used in HTTP probes +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HttpHeader { + /// Required. The header field name + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The header field value + #[prost(string, tag="2")] + pub value: ::prost::alloc::string::String, +} +/// TCPSocketAction describes an action based on opening a socket +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TcpSocketAction { + /// Port number to access on the container. Must be in the range 1 to 65535. + #[prost(int32, tag="1")] + pub port: i32, +} /// VPC Access settings. For more information on creating a VPC Connector, visit /// For /// information on how to configure Cloud Run with an existing VPC Connector, @@ -1034,15 +1129,17 @@ impl TrafficTargetAllocationType { /// Request message for creating a Service. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateServiceRequest { - /// Required. The location and project in which this service should be created. - /// Format: projects/{projectnumber}/locations/{location} + /// The location and project in which this service should be created. + /// Format: projects/{project}/locations/{location} + /// Only lowercase characters, digits, and hyphens. #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, /// Required. The Service instance to create. #[prost(message, optional, tag="2")] pub service: ::core::option::Option, - /// Required. The unique identifier for the Service. The name of the service becomes - /// {parent}/services/{service_id}. + /// Required. The unique identifier for the Service. It must begin with letter, + /// and may not end with hyphen; must contain fewer than 50 characters. + /// The name of the service becomes {parent}/services/{service_id}. #[prost(string, tag="3")] pub service_id: ::prost::alloc::string::String, /// Indicates that the request should be validated and default values @@ -1071,7 +1168,7 @@ pub struct UpdateServiceRequest { pub struct ListServicesRequest { /// Required. The location and project to list resources on. /// Location must be a valid GCP region, and may not be the "-" wildcard. - /// Format: projects/{projectnumber}/locations/{location} + /// Format: projects/{project}/locations/{location} #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, /// Maximum number of Services to return in this call. @@ -1100,7 +1197,7 @@ pub struct ListServicesResponse { #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetServiceRequest { /// Required. The full name of the Service. - /// Format: projects/{projectnumber}/locations/{location}/services/{service} + /// Format: projects/{project}/locations/{location}/services/{service} #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, } @@ -1108,7 +1205,7 @@ pub struct GetServiceRequest { #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteServiceRequest { /// Required. The full name of the Service. - /// Format: projects/{projectnumber}/locations/{location}/services/{service} + /// Format: projects/{project}/locations/{location}/services/{service} #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, /// Indicates that the request should be validated without actually diff --git a/gcloud-sdk/genproto/google.cloud.securitycenter.v1.rs b/gcloud-sdk/genproto/google.cloud.securitycenter.v1.rs index adefbee92..09c590b05 100644 --- a/gcloud-sdk/genproto/google.cloud.securitycenter.v1.rs +++ b/gcloud-sdk/genproto/google.cloud.securitycenter.v1.rs @@ -2027,8 +2027,8 @@ pub struct Source { /// 2. Once a bulk operation is started, there is no way to stop it. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BulkMuteFindingsRequest { - /// Required. The parent, at which bulk action needs to be applied. Its format is - /// "organizations/\[organization_id\]", "folders/\[folder_id\]", + /// Required. The parent, at which bulk action needs to be applied. Its format + /// is "organizations/\[organization_id\]", "folders/\[folder_id\]", /// "projects/\[project_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, @@ -2076,8 +2076,8 @@ pub struct CreateFindingRequest { /// greater than 0 characters in length. #[prost(string, tag="2")] pub finding_id: ::prost::alloc::string::String, - /// Required. The Finding being created. The name and security_marks will be ignored as - /// they are both output only fields on this resource. + /// Required. The Finding being created. The name and security_marks will be + /// ignored as they are both output only fields on this resource. #[prost(message, optional, tag="3")] pub finding: ::core::option::Option, } @@ -2102,8 +2102,9 @@ pub struct CreateMuteConfigRequest { /// Request message for creating a notification config. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateNotificationConfigRequest { - /// Required. Resource name of the new notification config's parent. Its format is - /// "organizations/\[organization_id\]". + /// Required. Resource name of the new notification config's parent. Its format + /// is "organizations/\[organization_id\]", "folders/\[folder_id\]", or + /// "projects/\[project_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, /// Required. @@ -2112,8 +2113,9 @@ pub struct CreateNotificationConfigRequest { /// characters, underscores or hyphens only. #[prost(string, tag="2")] pub config_id: ::prost::alloc::string::String, - /// Required. The notification config being created. The name and the service account - /// will be ignored as they are both output only fields on this resource. + /// Required. The notification config being created. The name and the service + /// account will be ignored as they are both output only fields on this + /// resource. #[prost(message, optional, tag="3")] pub notification_config: ::core::option::Option, } @@ -2124,8 +2126,8 @@ pub struct CreateSourceRequest { /// "organizations/\[organization_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, - /// Required. The Source being created, only the display_name and description will be - /// used. All other fields will be ignored. + /// Required. The Source being created, only the display_name and description + /// will be used. All other fields will be ignored. #[prost(message, optional, tag="2")] pub source: ::core::option::Option, } @@ -2178,8 +2180,8 @@ pub struct GetNotificationConfigRequest { /// Request message for getting organization settings. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetOrganizationSettingsRequest { - /// Required. Name of the organization to get organization settings for. Its format is - /// "organizations/\[organization_id\]/organizationSettings". + /// Required. Name of the organization to get organization settings for. Its + /// format is "organizations/\[organization_id\]/organizationSettings". #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, } @@ -2263,9 +2265,9 @@ pub struct GroupAssetsRequest { /// property not existing: `-resource_properties.my_property : ""` #[prost(string, tag="2")] pub filter: ::prost::alloc::string::String, - /// Required. Expression that defines what assets fields to use for grouping. The string - /// value should follow SQL syntax: comma separated list of fields. For - /// example: + /// Required. Expression that defines what assets fields to use for grouping. + /// The string value should follow SQL syntax: comma separated list of fields. + /// For example: /// "security_center_properties.resource_project,security_center_properties.project". /// /// The following fields are supported when compare_duration is not set: @@ -2420,9 +2422,9 @@ pub struct GroupFindingsRequest { /// * resource.type: `=`, `:` #[prost(string, tag="2")] pub filter: ::prost::alloc::string::String, - /// Required. Expression that defines what assets fields to use for grouping (including - /// `state_change`). The string value should follow SQL syntax: comma separated - /// list of fields. For example: "parent,resource_name". + /// Required. Expression that defines what assets fields to use for grouping + /// (including `state_change`). The string value should follow SQL syntax: + /// comma separated list of fields. For example: "parent,resource_name". /// /// The following fields are supported: /// @@ -2520,8 +2522,8 @@ pub struct GroupResult { /// folder or project. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListMuteConfigsRequest { - /// Required. The parent, which owns the collection of mute configs. Its format is - /// "organizations/\[organization_id\]", "folders/\[folder_id\]", + /// Required. The parent, which owns the collection of mute configs. Its format + /// is "organizations/\[organization_id\]", "folders/\[folder_id\]", /// "projects/\[project_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, @@ -2553,8 +2555,9 @@ pub struct ListMuteConfigsResponse { /// Request message for listing notification configs. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListNotificationConfigsRequest { - /// Required. Name of the organization to list notification configs. - /// Its format is "organizations/\[organization_id\]". + /// Required. Name of the organization to list notification configs. Its format + /// is "organizations/\[organization_id\]", "folders/\[folder_id\]", or + /// "projects/\[project_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, /// The value returned by the last `ListNotificationConfigsResponse`; indicates @@ -2581,8 +2584,8 @@ pub struct ListNotificationConfigsResponse { /// Request message for listing sources. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListSourcesRequest { - /// Required. Resource name of the parent of sources to list. Its format should be - /// "organizations/\[organization_id\], folders/\[folder_id\], or + /// Required. Resource name of the parent of sources to list. Its format should + /// be "organizations/\[organization_id\], folders/\[folder_id\], or /// projects/\[project_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, @@ -3103,8 +3106,8 @@ pub struct SetMuteRequest { /// Request message for running asset discovery for an organization. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RunAssetDiscoveryRequest { - /// Required. Name of the organization to run asset discovery for. Its format is - /// "organizations/\[organization_id\]". + /// Required. Name of the organization to run asset discovery for. Its format + /// is "organizations/\[organization_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, } @@ -3123,8 +3126,8 @@ pub struct UpdateExternalSystemRequest { /// Request message for updating or creating a finding. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateFindingRequest { - /// Required. The finding resource to update or create if it does not already exist. - /// parent, security_marks, and update_time will be ignored. + /// Required. The finding resource to update or create if it does not already + /// exist. parent, security_marks, and update_time will be ignored. /// /// In the case of creation, the finding id portion of the name must be /// alphanumeric and less than or equal to 32 characters and greater than 0 @@ -3241,8 +3244,8 @@ pub struct UpdateBigQueryExportRequest { /// organization, folder or project. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListBigQueryExportsRequest { - /// Required. The parent, which owns the collection of BigQuery exports. Its format is - /// "organizations/\[organization_id\]", "folders/\[folder_id\]", + /// Required. The parent, which owns the collection of BigQuery exports. Its + /// format is "organizations/\[organization_id\]", "folders/\[folder_id\]", /// "projects/\[project_id\]". #[prost(string, tag="1")] pub parent: ::prost::alloc::string::String, diff --git a/gcloud-sdk/genproto/google.cloud.storageinsights.v1.rs b/gcloud-sdk/genproto/google.cloud.storageinsights.v1.rs new file mode 100644 index 000000000..78d9858fa --- /dev/null +++ b/gcloud-sdk/genproto/google.cloud.storageinsights.v1.rs @@ -0,0 +1,599 @@ +/// Message for requesting list of ReportConfigs +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListReportConfigsRequest { + /// Required. Parent value for ListReportConfigsRequest + #[prost(string, tag="1")] + pub parent: ::prost::alloc::string::String, + /// Requested page size. Server may return fewer items than requested. + /// If unspecified, server will pick an appropriate default. + #[prost(int32, tag="2")] + pub page_size: i32, + /// A token identifying a page of results the server should return. + #[prost(string, tag="3")] + pub page_token: ::prost::alloc::string::String, + /// Filtering results + #[prost(string, tag="4")] + pub filter: ::prost::alloc::string::String, + /// Hint for how to order the results + #[prost(string, tag="5")] + pub order_by: ::prost::alloc::string::String, +} +/// Message for response to listing ReportConfigs +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListReportConfigsResponse { + /// The list of ReportConfig + #[prost(message, repeated, tag="1")] + pub report_configs: ::prost::alloc::vec::Vec, + /// A token identifying a page of results the server should return. + #[prost(string, tag="2")] + pub next_page_token: ::prost::alloc::string::String, + /// Locations that could not be reached. + #[prost(string, repeated, tag="3")] + pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Message for getting a ReportConfig +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetReportConfigRequest { + /// Required. Name of the resource + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +/// Message for creating a ReportConfig +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateReportConfigRequest { + /// Required. Value for parent. + #[prost(string, tag="1")] + pub parent: ::prost::alloc::string::String, + /// Required. The resource being created + #[prost(message, optional, tag="3")] + pub report_config: ::core::option::Option, + /// Optional. An optional request ID to identify requests. Specify a unique request ID + /// so that if you must retry your request, the server will know to ignore + /// the request if it has already been completed. The server will guarantee + /// that for at least 60 minutes since the first request. + /// + /// For example, consider a situation where you make an initial request and t + /// he request times out. If you make the request again with the same request + /// ID, the server can check if original operation with the same request ID + /// was received, and if so, will ignore the second request. This prevents + /// clients from accidentally creating duplicate commitments. + /// + /// The request ID must be a valid UUID with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + #[prost(string, tag="4")] + pub request_id: ::prost::alloc::string::String, +} +/// Message for updating a ReportConfig +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateReportConfigRequest { + /// Required. Field mask is used to specify the fields to be overwritten in the + /// ReportConfig resource by the update. + /// The fields specified in the update_mask are relative to the resource, not + /// the full request. A field will be overwritten if it is in the mask. If the + /// user does not provide a mask then all fields will be overwritten. + #[prost(message, optional, tag="1")] + pub update_mask: ::core::option::Option<::prost_types::FieldMask>, + /// Required. The resource being updated + #[prost(message, optional, tag="2")] + pub report_config: ::core::option::Option, + /// Optional. An optional request ID to identify requests. Specify a unique request ID + /// so that if you must retry your request, the server will know to ignore + /// the request if it has already been completed. The server will guarantee + /// that for at least 60 minutes since the first request. + /// + /// For example, consider a situation where you make an initial request and t + /// he request times out. If you make the request again with the same request + /// ID, the server can check if original operation with the same request ID + /// was received, and if so, will ignore the second request. This prevents + /// clients from accidentally creating duplicate commitments. + /// + /// The request ID must be a valid UUID with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + #[prost(string, tag="3")] + pub request_id: ::prost::alloc::string::String, +} +/// Message for deleting a ReportConfig +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteReportConfigRequest { + /// Required. Name of the resource + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Optional. If set, all ReportDetails for this ReportConfig will be deleted. + #[prost(bool, tag="2")] + pub force: bool, + /// Optional. An optional request ID to identify requests. Specify a unique request ID + /// so that if you must retry your request, the server will know to ignore + /// the request if it has already been completed. The server will guarantee + /// that for at least 60 minutes after the first request. + /// + /// For example, consider a situation where you make an initial request and t + /// he request times out. If you make the request again with the same request + /// ID, the server can check if original operation with the same request ID + /// was received, and if so, will ignore the second request. This prevents + /// clients from accidentally creating duplicate commitments. + /// + /// The request ID must be a valid UUID with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + #[prost(string, tag="3")] + pub request_id: ::prost::alloc::string::String, +} +/// Message describing ReportDetail object. ReportDetail represents metadata of +/// generated reports for a ReportConfig. +/// Next ID: 8 +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReportDetail { + /// Name of resource. It will be of form + /// projects//locations//reportConfigs//reportDetails/. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The snapshot time. + /// All the report data is referenced at this point of time. + #[prost(message, optional, tag="2")] + pub snapshot_time: ::core::option::Option<::prost_types::Timestamp>, + /// Generated report's full path with name. It will be of the form + /// destination_bucket//. + #[prost(string, repeated, tag="3")] + pub report_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Status of the ReportDetail. + #[prost(message, optional, tag="4")] + pub status: ::core::option::Option, + /// Labels as key value pairs + #[prost(map="string, string", tag="5")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// The date for which report is generated. The time part of target_datetime + /// will be zero till we support multiple reports per day. + #[prost(message, optional, tag="6")] + pub target_datetime: ::core::option::Option, + /// Metrics of the report. + #[prost(message, optional, tag="7")] + pub report_metrics: ::core::option::Option, +} +/// Nested message and enum types in `ReportDetail`. +pub mod report_detail { + /// Different metrics associated with the generated report. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Metrics { + /// Count of Cloud Storage objects which are part of the report. + #[prost(int64, tag="1")] + pub processed_records_count: i64, + } +} +/// Message for requesting list of ReportDetails +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListReportDetailsRequest { + /// Required. Parent value for ListReportDetailsRequest + #[prost(string, tag="1")] + pub parent: ::prost::alloc::string::String, + /// Requested page size. Server may return fewer items than requested. + /// If unspecified, server will pick an appropriate default. + #[prost(int32, tag="2")] + pub page_size: i32, + /// A token identifying a page of results the server should return. + #[prost(string, tag="3")] + pub page_token: ::prost::alloc::string::String, + /// Filtering results + #[prost(string, tag="4")] + pub filter: ::prost::alloc::string::String, + /// Hint for how to order the results + #[prost(string, tag="5")] + pub order_by: ::prost::alloc::string::String, +} +/// Message for response to listing ReportDetails +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListReportDetailsResponse { + /// The list of ReportDetail + #[prost(message, repeated, tag="1")] + pub report_details: ::prost::alloc::vec::Vec, + /// A token identifying a page of results the server should return. + #[prost(string, tag="2")] + pub next_page_token: ::prost::alloc::string::String, + /// Locations that could not be reached. + #[prost(string, repeated, tag="3")] + pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Message for getting a ReportDetail +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetReportDetailRequest { + /// Required. Name of the resource + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +/// Represents the metadata of the long-running operation. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OperationMetadata { + /// Output only. The time the operation was created. + #[prost(message, optional, tag="1")] + pub create_time: ::core::option::Option<::prost_types::Timestamp>, + /// Output only. The time the operation finished running. + #[prost(message, optional, tag="2")] + pub end_time: ::core::option::Option<::prost_types::Timestamp>, + /// Output only. Server-defined resource path for the target of the operation. + #[prost(string, tag="3")] + pub target: ::prost::alloc::string::String, + /// Output only. Name of the verb executed by the operation. + #[prost(string, tag="4")] + pub verb: ::prost::alloc::string::String, + /// Output only. Human-readable status of the operation, if any. + #[prost(string, tag="5")] + pub status_message: ::prost::alloc::string::String, + /// Output only. Identifies whether the user has requested cancellation + /// of the operation. Operations that have been cancelled successfully + /// have \[Operation.error][\] value with a \[google.rpc.Status.code][google.rpc.Status.code\] of 1, + /// corresponding to `Code.CANCELLED`. + #[prost(bool, tag="6")] + pub requested_cancellation: bool, + /// Output only. API version used to start the operation. + #[prost(string, tag="7")] + pub api_version: ::prost::alloc::string::String, +} +/// ************************************************************************* +/// * * +/// * ReportConfig Resource * +/// * * +/// ************************************************************************* +/// Options to setup frequency of report generation. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FrequencyOptions { + /// Frequency of report generation. + #[prost(enumeration="frequency_options::Frequency", tag="1")] + pub frequency: i32, + /// The date from which report generation should start. // UTC Timezone. + #[prost(message, optional, tag="2")] + pub start_date: ::core::option::Option, + /// The date on which report generation should stop (Inclusive). // UTC + /// Timezone. + #[prost(message, optional, tag="3")] + pub end_date: ::core::option::Option, +} +/// Nested message and enum types in `FrequencyOptions`. +pub mod frequency_options { + /// This ENUM specifies possible frequencies of report generation. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Frequency { + /// Unspecified. + Unspecified = 0, + /// Report will be generated daily. + Daily = 1, + /// Report will be generated weekly. + Weekly = 2, + } + impl Frequency { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Frequency::Unspecified => "FREQUENCY_UNSPECIFIED", + Frequency::Daily => "DAILY", + Frequency::Weekly => "WEEKLY", + } + } + } +} +/// Options to configure CSV formatted reports. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CsvOptions { + /// Record separator characters in CSV. + #[prost(string, tag="1")] + pub record_separator: ::prost::alloc::string::String, + /// Delimiter characters in CSV. + #[prost(string, tag="2")] + pub delimiter: ::prost::alloc::string::String, + /// If set, will include a header row in the CSV report. + #[prost(bool, tag="3")] + pub header_required: bool, +} +/// Options to filter data on storage systems. +/// Next ID: 2 +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CloudStorageFilters { + /// Bucket for which the report will be generated. + #[prost(string, tag="1")] + pub bucket: ::prost::alloc::string::String, +} +/// Options to store reports in storage systems. +/// Next ID: 3 +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CloudStorageDestinationOptions { + /// Destination bucket. + #[prost(string, tag="1")] + pub bucket: ::prost::alloc::string::String, + /// Destination path is the path in the bucket where the report should be + /// generated. + #[prost(string, tag="2")] + pub destination_path: ::prost::alloc::string::String, +} +/// Report specification for exporting object metadata. +/// Next ID: 4 +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ObjectMetadataReportOptions { + /// Metadata fields to be included in the report. + #[prost(string, repeated, tag="1")] + pub metadata_fields: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Filter options for storage systems. + #[prost(oneof="object_metadata_report_options::Filter", tags="2")] + pub filter: ::core::option::Option, + /// Options on destination for storage systems. + #[prost(oneof="object_metadata_report_options::DestinationOptions", tags="3")] + pub destination_options: ::core::option::Option, +} +/// Nested message and enum types in `ObjectMetadataReportOptions`. +pub mod object_metadata_report_options { + /// Filter options for storage systems. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Filter { + /// Cloud Storage as the storage system. + #[prost(message, tag="2")] + StorageFilters(super::CloudStorageFilters), + } + /// Options on destination for storage systems. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum DestinationOptions { + /// Cloud Storage as the storage system. + #[prost(message, tag="3")] + StorageDestinationOptions(super::CloudStorageDestinationOptions), + } +} +/// Message describing ReportConfig object. ReportConfig is the configuration to +/// generate reports. +/// Next ID: 12 +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReportConfig { + /// name of resource. It will be of form + /// projects//locations//reportConfigs/. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Output only. [Output only] Create time stamp + #[prost(message, optional, tag="2")] + pub create_time: ::core::option::Option<::prost_types::Timestamp>, + /// Output only. [Output only] Update time stamp + #[prost(message, optional, tag="3")] + pub update_time: ::core::option::Option<::prost_types::Timestamp>, + /// The frequency of report generation. + #[prost(message, optional, tag="5")] + pub frequency_options: ::core::option::Option, + /// Labels as key value pairs + #[prost(map="string, string", tag="10")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// User provided display name which can be empty and limited to 256 characters + /// that is editable. + #[prost(string, tag="11")] + pub display_name: ::prost::alloc::string::String, + /// Format in which report will be published. + #[prost(oneof="report_config::ReportFormat", tags="6")] + pub report_format: ::core::option::Option, + /// Configuration options for report contents. + #[prost(oneof="report_config::ReportKind", tags="8")] + pub report_kind: ::core::option::Option, +} +/// Nested message and enum types in `ReportConfig`. +pub mod report_config { + /// Format in which report will be published. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ReportFormat { + /// Options for CSV formatted reports. + #[prost(message, tag="6")] + CsvOptions(super::CsvOptions), + } + /// Configuration options for report contents. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ReportKind { + /// Report for exporting object metadata. + #[prost(message, tag="8")] + ObjectMetadataReportOptions(super::ObjectMetadataReportOptions), + } +} +/// Generated client implementations. +pub mod storage_insights_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// Service describing handlers for resources + #[derive(Debug, Clone)] + pub struct StorageInsightsClient { + inner: tonic::client::Grpc, + } + impl StorageInsightsClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: std::convert::TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl StorageInsightsClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> StorageInsightsClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + StorageInsightsClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Lists ReportConfigs in a given project and location. + pub async fn list_report_configs( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/ListReportConfigs", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Gets details of a single ReportConfig. + pub async fn get_report_config( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/GetReportConfig", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Creates a new ReportConfig in a given project and location. + pub async fn create_report_config( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/CreateReportConfig", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Updates the parameters of a single ReportConfig. + pub async fn update_report_config( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/UpdateReportConfig", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Deletes a single ReportConfig. + pub async fn delete_report_config( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/DeleteReportConfig", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Lists ReportDetails in a given project and location. + pub async fn list_report_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/ListReportDetails", + ); + self.inner.unary(request.into_request(), path, codec).await + } + /// Gets details of a single ReportDetail. + pub async fn get_report_detail( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/google.cloud.storageinsights.v1.StorageInsights/GetReportDetail", + ); + self.inner.unary(request.into_request(), path, codec).await + } + } +} diff --git a/gcloud-sdk/genproto/google.cloud.webrisk.v1.rs b/gcloud-sdk/genproto/google.cloud.webrisk.v1.rs index 252e92269..027942ce3 100644 --- a/gcloud-sdk/genproto/google.cloud.webrisk.v1.rs +++ b/gcloud-sdk/genproto/google.cloud.webrisk.v1.rs @@ -1,7 +1,9 @@ /// Describes an API diff request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ComputeThreatListDiffRequest { - /// Required. The threat list to update. Only a single ThreatType should be specified. + /// Required. The threat list to update. Only a single ThreatType should be specified + /// per request. If you want to handle multiple ThreatTypes, you must make one + /// request per ThreatType. #[prost(enumeration="ThreatType", tag="1")] pub threat_type: i32, /// The current version token of the client for the requested list (the @@ -115,7 +117,7 @@ pub struct SearchUrisRequest { } #[derive(Clone, PartialEq, ::prost::Message)] pub struct SearchUrisResponse { - /// The threat list matches. This may be empty if the URI is on no list. + /// The threat list matches. This might be empty if the URI is on no list. #[prost(message, optional, tag="1")] pub threat: ::core::option::Option, } @@ -138,6 +140,8 @@ pub mod search_uris_response { pub struct SearchHashesRequest { /// A hash prefix, consisting of the most significant 4-32 bytes of a SHA256 /// hash. For JSON requests, this field is base64-encoded. + /// Note that if this parameter is provided by a URI, it must be encoded using + /// the web safe base64 variant (RFC 4648). #[prost(bytes="vec", tag="1")] pub hash_prefix: ::prost::alloc::vec::Vec, /// Required. The ThreatLists to search in. Multiple ThreatLists may be specified. @@ -251,10 +255,10 @@ pub struct RiceDeltaEncoding { #[prost(bytes="vec", tag="4")] pub encoded_data: ::prost::alloc::vec::Vec, } -/// Wraps a URI that might be displaying phishing content. +/// Wraps a URI that might be displaying malicious content. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Submission { - /// Required. The URI that is being reported for phishing content to be analyzed. + /// Required. The URI that is being reported for malicious content to be analyzed. #[prost(string, tag="1")] pub uri: ::prost::alloc::string::String, } @@ -269,12 +273,12 @@ pub struct CreateSubmissionRequest { #[prost(message, optional, tag="2")] pub submission: ::core::option::Option, } -/// The type of threat. This maps dirrectly to the threat list a threat may +/// The type of threat. This maps directly to the threat list a threat may /// belong to. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ThreatType { - /// Unknown. + /// No entries should match this threat type. This threat type is unused. Unspecified = 0, /// Malware targeting any platform. Malware = 1, @@ -282,6 +286,9 @@ pub enum ThreatType { SocialEngineering = 2, /// Unwanted software targeting any platform. UnwantedSoftware = 3, + /// A list of extended coverage social engineering URIs targeting any + /// platform. + SocialEngineeringExtendedCoverage = 4, } impl ThreatType { /// String value of the enum field names used in the ProtoBuf definition. @@ -294,6 +301,7 @@ impl ThreatType { ThreatType::Malware => "MALWARE", ThreatType::SocialEngineering => "SOCIAL_ENGINEERING", ThreatType::UnwantedSoftware => "UNWANTED_SOFTWARE", + ThreatType::SocialEngineeringExtendedCoverage => "SOCIAL_ENGINEERING_EXTENDED_COVERAGE", } } } @@ -473,7 +481,8 @@ pub mod web_risk_service_client { /// content, the site will be added to the [Google's Social Engineering /// lists](https://support.google.com/webmasters/answer/6350487/) in order to /// protect users that could get exposed to this threat in the future. Only - /// projects with CREATE_SUBMISSION_USERS visibility can use this method. + /// allowlisted projects can use this method during Early Access. Please reach + /// out to Sales or your customer engineer to obtain access. pub async fn create_submission( &mut self, request: impl tonic::IntoRequest, diff --git a/gcloud-sdk/genproto/google.spanner.v1.rs b/gcloud-sdk/genproto/google.spanner.v1.rs index 96be64309..ccbc88126 100644 --- a/gcloud-sdk/genproto/google.spanner.v1.rs +++ b/gcloud-sdk/genproto/google.spanner.v1.rs @@ -412,7 +412,8 @@ pub struct QueryPlan { /// /// Queries on change streams must be performed with the snapshot read-only /// transaction mode, specifying a strong read. Please see -/// \[TransactionOptions.ReadOnly.strong][google.spanner.v1.TransactionOptions.ReadOnly.strong\] for more details. +/// \[TransactionOptions.ReadOnly.strong][google.spanner.v1.TransactionOptions.ReadOnly.strong\] +/// for more details. /// /// 3. Partitioned DML. This type of transaction is used to execute /// a single Partitioned DML statement. Partitioned DML partitions @@ -548,7 +549,8 @@ pub struct QueryPlan { /// Queries on change streams (see below for more details) must also specify /// the strong read timestamp bound. /// -/// See \[TransactionOptions.ReadOnly.strong][google.spanner.v1.TransactionOptions.ReadOnly.strong\]. +/// See +/// \[TransactionOptions.ReadOnly.strong][google.spanner.v1.TransactionOptions.ReadOnly.strong\]. /// /// Exact staleness: /// @@ -569,7 +571,9 @@ pub struct QueryPlan { /// equivalent boundedly stale concurrency modes. On the other hand, /// boundedly stale reads usually return fresher results. /// -/// See \[TransactionOptions.ReadOnly.read_timestamp][google.spanner.v1.TransactionOptions.ReadOnly.read_timestamp\] and +/// See +/// \[TransactionOptions.ReadOnly.read_timestamp][google.spanner.v1.TransactionOptions.ReadOnly.read_timestamp\] +/// and /// \[TransactionOptions.ReadOnly.exact_staleness][google.spanner.v1.TransactionOptions.ReadOnly.exact_staleness\]. /// /// Bounded staleness: @@ -599,7 +603,9 @@ pub struct QueryPlan { /// which rows will be read, it can only be used with single-use /// read-only transactions. /// -/// See \[TransactionOptions.ReadOnly.max_staleness][google.spanner.v1.TransactionOptions.ReadOnly.max_staleness\] and +/// See +/// \[TransactionOptions.ReadOnly.max_staleness][google.spanner.v1.TransactionOptions.ReadOnly.max_staleness\] +/// and /// \[TransactionOptions.ReadOnly.min_read_timestamp][google.spanner.v1.TransactionOptions.ReadOnly.min_read_timestamp\]. /// /// Old read timestamps and garbage collection: @@ -713,6 +719,45 @@ pub mod transaction_options { /// transaction type has no options. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadWrite { + /// Read lock mode for the transaction. + #[prost(enumeration="read_write::ReadLockMode", tag="1")] + pub read_lock_mode: i32, + } + /// Nested message and enum types in `ReadWrite`. + pub mod read_write { + /// `ReadLockMode` is used to set the read lock mode for read-write + /// transactions. + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum ReadLockMode { + /// Default value. + /// + /// If the value is not specified, the pessimistic read lock is used. + Unspecified = 0, + /// Pessimistic lock mode. + /// + /// Read locks are acquired immediately on read. + Pessimistic = 1, + /// Optimistic lock mode. + /// + /// Locks for reads within the transaction are not acquired on read. + /// Instead the locks are acquired on a commit to validate that + /// read/queried data has not changed since the transaction started. + Optimistic = 2, + } + impl ReadLockMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ReadLockMode::Unspecified => "READ_LOCK_MODE_UNSPECIFIED", + ReadLockMode::Pessimistic => "PESSIMISTIC", + ReadLockMode::Optimistic => "OPTIMISTIC", + } + } + } } /// Message type to initiate a Partitioned DML transaction. #[derive(Clone, PartialEq, ::prost::Message)] @@ -722,7 +767,8 @@ pub mod transaction_options { #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadOnly { /// If true, the Cloud Spanner-selected read timestamp is included in - /// the \[Transaction][google.spanner.v1.Transaction\] message that describes the transaction. + /// the \[Transaction][google.spanner.v1.Transaction\] message that describes + /// the transaction. #[prost(bool, tag="6")] pub return_read_timestamp: bool, /// How to choose the timestamp for the read-only transaction. @@ -846,7 +892,8 @@ pub struct Transaction { /// \[Read][google.spanner.v1.Spanner.Read\] or /// \[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql\] call runs. /// -/// See \[TransactionOptions][google.spanner.v1.TransactionOptions\] for more information about transactions. +/// See \[TransactionOptions][google.spanner.v1.TransactionOptions\] for more +/// information about transactions. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TransactionSelector { /// If no fields are set, the default is a single use transaction @@ -870,7 +917,8 @@ pub mod transaction_selector { Id(::prost::alloc::vec::Vec), /// Begin a new transaction and execute this read or SQL query in /// it. The transaction ID of the new transaction is returned in - /// \[ResultSetMetadata.transaction][google.spanner.v1.ResultSetMetadata.transaction\], which is a \[Transaction][google.spanner.v1.Transaction\]. + /// \[ResultSetMetadata.transaction][google.spanner.v1.ResultSetMetadata.transaction\], + /// which is a \[Transaction][google.spanner.v1.Transaction\]. #[prost(message, tag="3")] Begin(super::TransactionOptions), } diff --git a/gcloud-sdk/genproto/maps.fleetengine.delivery.v1.rs b/gcloud-sdk/genproto/maps.fleetengine.delivery.v1.rs index 5228b9c15..a44d3c3cc 100644 --- a/gcloud-sdk/genproto/maps.fleetengine.delivery.v1.rs +++ b/gcloud-sdk/genproto/maps.fleetengine.delivery.v1.rs @@ -808,6 +808,11 @@ pub struct ListDeliveryVehiclesRequest { /// boolean values, the values must be explicitly quoted to be treated as /// strings (for example, `attributes. = "10"` or /// `attributes. = "true"`). + /// + /// The maximum number of restrictions allowed in a filter query is 50. A + /// restriction is a part of the query of the form + /// `attribute. `, for example `attributes.foo = bar` + /// is 1 restriction. #[prost(string, tag="6")] pub filter: ::prost::alloc::string::String, /// Optional. A filter that limits the search area to a rectangle defined by the