google_cloud_bigquery_datatransfer_v1/

model.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gax;
extern crate gaxi;
extern crate lazy_static;
extern crate location;
extern crate reqwest;
extern crate rpc;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

/// A parameter used to define custom fields in a data source definition.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DataSourceParameter {
    /// Parameter identifier.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub param_id: std::string::String,

    /// Parameter display name in the user interface.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Parameter description.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Parameter type.
    #[serde(rename = "type")]
    pub r#type: crate::model::data_source_parameter::Type,

    /// Is parameter required.
    pub required: bool,

    /// Deprecated. This field has no effect.
    pub repeated: bool,

    /// Regular expression which can be used for parameter validation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub validation_regex: std::string::String,

    /// All possible values for the parameter.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub allowed_values: std::vec::Vec<std::string::String>,

    /// For integer and double values specifies minimum allowed value.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub min_value: std::option::Option<wkt::DoubleValue>,

    /// For integer and double values specifies maximum allowed value.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub max_value: std::option::Option<wkt::DoubleValue>,

    /// Deprecated. This field has no effect.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub fields: std::vec::Vec<crate::model::DataSourceParameter>,

    /// Description of the requirements for this field, in case the user input does
    /// not fulfill the regex pattern or min/max values.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub validation_description: std::string::String,

    /// URL to a help document to further explain the naming requirements.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub validation_help_url: std::string::String,

    /// Cannot be changed after initial creation.
    pub immutable: bool,

    /// Deprecated. This field has no effect.
    pub recurse: bool,

    /// If true, it should not be used in new transfers, and it should not be
    /// visible to users.
    pub deprecated: bool,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DataSourceParameter {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [param_id][crate::model::DataSourceParameter::param_id].
    pub fn set_param_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.param_id = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::DataSourceParameter::display_name].
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [description][crate::model::DataSourceParameter::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [r#type][crate::model::DataSourceParameter::type].
    pub fn set_type<T: std::convert::Into<crate::model::data_source_parameter::Type>>(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

    /// Sets the value of [required][crate::model::DataSourceParameter::required].
    pub fn set_required<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.required = v.into();
        self
    }

    /// Sets the value of [repeated][crate::model::DataSourceParameter::repeated].
    pub fn set_repeated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.repeated = v.into();
        self
    }

    /// Sets the value of [validation_regex][crate::model::DataSourceParameter::validation_regex].
    pub fn set_validation_regex<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.validation_regex = v.into();
        self
    }

    /// Sets the value of [min_value][crate::model::DataSourceParameter::min_value].
    pub fn set_min_value<T: std::convert::Into<std::option::Option<wkt::DoubleValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.min_value = v.into();
        self
    }

    /// Sets the value of [max_value][crate::model::DataSourceParameter::max_value].
    pub fn set_max_value<T: std::convert::Into<std::option::Option<wkt::DoubleValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.max_value = v.into();
        self
    }

    /// Sets the value of [validation_description][crate::model::DataSourceParameter::validation_description].
    pub fn set_validation_description<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.validation_description = v.into();
        self
    }

    /// Sets the value of [validation_help_url][crate::model::DataSourceParameter::validation_help_url].
    pub fn set_validation_help_url<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.validation_help_url = v.into();
        self
    }

    /// Sets the value of [immutable][crate::model::DataSourceParameter::immutable].
    pub fn set_immutable<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.immutable = v.into();
        self
    }

    /// Sets the value of [recurse][crate::model::DataSourceParameter::recurse].
    pub fn set_recurse<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.recurse = v.into();
        self
    }

    /// Sets the value of [deprecated][crate::model::DataSourceParameter::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [allowed_values][crate::model::DataSourceParameter::allowed_values].
    pub fn set_allowed_values<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.allowed_values = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [fields][crate::model::DataSourceParameter::fields].
    pub fn set_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DataSourceParameter>,
    {
        use std::iter::Iterator;
        self.fields = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for DataSourceParameter {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.DataSourceParameter"
    }
}

/// Defines additional types related to [DataSourceParameter].
pub mod data_source_parameter {
    #[allow(unused_imports)]
    use super::*;

    /// Parameter type.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct Type(i32);

    impl Type {
        /// Type unspecified.
        pub const TYPE_UNSPECIFIED: Type = Type::new(0);

        /// String parameter.
        pub const STRING: Type = Type::new(1);

        /// Integer parameter (64-bits).
        /// Will be serialized to json as string.
        pub const INTEGER: Type = Type::new(2);

        /// Double precision floating point parameter.
        pub const DOUBLE: Type = Type::new(3);

        /// Boolean parameter.
        pub const BOOLEAN: Type = Type::new(4);

        /// Deprecated. This field has no effect.
        pub const RECORD: Type = Type::new(5);

        /// Page ID for a Google+ Page.
        pub const PLUS_PAGE: Type = Type::new(6);

        /// List of strings parameter.
        pub const LIST: Type = Type::new(7);

        /// Creates a new Type instance.
        pub(crate) const fn new(value: i32) -> Self {
            Self(value)
        }

        /// Gets the enum value.
        pub fn value(&self) -> i32 {
            self.0
        }

        /// Gets the enum value as a string.
        pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
            match self.0 {
                0 => std::borrow::Cow::Borrowed("TYPE_UNSPECIFIED"),
                1 => std::borrow::Cow::Borrowed("STRING"),
                2 => std::borrow::Cow::Borrowed("INTEGER"),
                3 => std::borrow::Cow::Borrowed("DOUBLE"),
                4 => std::borrow::Cow::Borrowed("BOOLEAN"),
                5 => std::borrow::Cow::Borrowed("RECORD"),
                6 => std::borrow::Cow::Borrowed("PLUS_PAGE"),
                7 => std::borrow::Cow::Borrowed("LIST"),
                _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
            }
        }

        /// Creates an enum value from the value name.
        pub fn from_str_name(name: &str) -> std::option::Option<Self> {
            match name {
                "TYPE_UNSPECIFIED" => std::option::Option::Some(Self::TYPE_UNSPECIFIED),
                "STRING" => std::option::Option::Some(Self::STRING),
                "INTEGER" => std::option::Option::Some(Self::INTEGER),
                "DOUBLE" => std::option::Option::Some(Self::DOUBLE),
                "BOOLEAN" => std::option::Option::Some(Self::BOOLEAN),
                "RECORD" => std::option::Option::Some(Self::RECORD),
                "PLUS_PAGE" => std::option::Option::Some(Self::PLUS_PAGE),
                "LIST" => std::option::Option::Some(Self::LIST),
                _ => std::option::Option::None,
            }
        }
    }

    impl std::convert::From<i32> for Type {
        fn from(value: i32) -> Self {
            Self::new(value)
        }
    }

    impl std::default::Default for Type {
        fn default() -> Self {
            Self::new(0)
        }
    }
}

/// Defines the properties and custom parameters for a data source.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DataSource {
    /// Output only. Data source resource name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Data source id.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub data_source_id: std::string::String,

    /// User friendly data source name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// User friendly data source description string.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Data source client id which should be used to receive refresh token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub client_id: std::string::String,

    /// Api auth scopes for which refresh token needs to be obtained. These are
    /// scopes needed by a data source to prepare data and ingest them into
    /// BigQuery, e.g., <https://www.googleapis.com/auth/bigquery>
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub scopes: std::vec::Vec<std::string::String>,

    /// Deprecated. This field has no effect.
    pub transfer_type: crate::model::TransferType,

    /// Deprecated. This field has no effect.
    pub supports_multiple_transfers: bool,

    /// The number of seconds to wait for an update from the data source
    /// before the Data Transfer Service marks the transfer as FAILED.
    pub update_deadline_seconds: i32,

    /// Default data transfer schedule.
    /// Examples of valid schedules include:
    /// `1st,3rd monday of month 15:30`,
    /// `every wed,fri of jan,jun 13:15`, and
    /// `first sunday of quarter 00:00`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub default_schedule: std::string::String,

    /// Specifies whether the data source supports a user defined schedule, or
    /// operates on the default schedule.
    /// When set to `true`, user can override default schedule.
    pub supports_custom_schedule: bool,

    /// Data source parameters.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub parameters: std::vec::Vec<crate::model::DataSourceParameter>,

    /// Url for the help document for this data source.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub help_url: std::string::String,

    /// Indicates the type of authorization.
    pub authorization_type: crate::model::data_source::AuthorizationType,

    /// Specifies whether the data source supports automatic data refresh for the
    /// past few days, and how it's supported.
    /// For some data sources, data might not be complete until a few days later,
    /// so it's useful to refresh data automatically.
    pub data_refresh_type: crate::model::data_source::DataRefreshType,

    /// Default data refresh window on days.
    /// Only meaningful when `data_refresh_type` = `SLIDING_WINDOW`.
    pub default_data_refresh_window_days: i32,

    /// Disables backfilling and manual run scheduling
    /// for the data source.
    pub manual_runs_disabled: bool,

    /// The minimum interval for scheduler to schedule runs.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub minimum_schedule_interval: std::option::Option<wkt::Duration>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DataSource {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DataSource::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [data_source_id][crate::model::DataSource::data_source_id].
    pub fn set_data_source_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.data_source_id = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::DataSource::display_name].
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [description][crate::model::DataSource::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [client_id][crate::model::DataSource::client_id].
    pub fn set_client_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.client_id = v.into();
        self
    }

    /// Sets the value of [transfer_type][crate::model::DataSource::transfer_type].
    pub fn set_transfer_type<T: std::convert::Into<crate::model::TransferType>>(
        mut self,
        v: T,
    ) -> Self {
        self.transfer_type = v.into();
        self
    }

    /// Sets the value of [supports_multiple_transfers][crate::model::DataSource::supports_multiple_transfers].
    pub fn set_supports_multiple_transfers<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.supports_multiple_transfers = v.into();
        self
    }

    /// Sets the value of [update_deadline_seconds][crate::model::DataSource::update_deadline_seconds].
    pub fn set_update_deadline_seconds<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.update_deadline_seconds = v.into();
        self
    }

    /// Sets the value of [default_schedule][crate::model::DataSource::default_schedule].
    pub fn set_default_schedule<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.default_schedule = v.into();
        self
    }

    /// Sets the value of [supports_custom_schedule][crate::model::DataSource::supports_custom_schedule].
    pub fn set_supports_custom_schedule<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.supports_custom_schedule = v.into();
        self
    }

    /// Sets the value of [help_url][crate::model::DataSource::help_url].
    pub fn set_help_url<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.help_url = v.into();
        self
    }

    /// Sets the value of [authorization_type][crate::model::DataSource::authorization_type].
    pub fn set_authorization_type<
        T: std::convert::Into<crate::model::data_source::AuthorizationType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_type = v.into();
        self
    }

    /// Sets the value of [data_refresh_type][crate::model::DataSource::data_refresh_type].
    pub fn set_data_refresh_type<
        T: std::convert::Into<crate::model::data_source::DataRefreshType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.data_refresh_type = v.into();
        self
    }

    /// Sets the value of [default_data_refresh_window_days][crate::model::DataSource::default_data_refresh_window_days].
    pub fn set_default_data_refresh_window_days<T: std::convert::Into<i32>>(
        mut self,
        v: T,
    ) -> Self {
        self.default_data_refresh_window_days = v.into();
        self
    }

    /// Sets the value of [manual_runs_disabled][crate::model::DataSource::manual_runs_disabled].
    pub fn set_manual_runs_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.manual_runs_disabled = v.into();
        self
    }

    /// Sets the value of [minimum_schedule_interval][crate::model::DataSource::minimum_schedule_interval].
    pub fn set_minimum_schedule_interval<
        T: std::convert::Into<std::option::Option<wkt::Duration>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.minimum_schedule_interval = v.into();
        self
    }

    /// Sets the value of [scopes][crate::model::DataSource::scopes].
    pub fn set_scopes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.scopes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [parameters][crate::model::DataSource::parameters].
    pub fn set_parameters<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DataSourceParameter>,
    {
        use std::iter::Iterator;
        self.parameters = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for DataSource {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.DataSource"
    }
}

/// Defines additional types related to [DataSource].
pub mod data_source {
    #[allow(unused_imports)]
    use super::*;

    /// The type of authorization needed for this data source.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct AuthorizationType(i32);

    impl AuthorizationType {
        /// Type unspecified.
        pub const AUTHORIZATION_TYPE_UNSPECIFIED: AuthorizationType = AuthorizationType::new(0);

        /// Use OAuth 2 authorization codes that can be exchanged
        /// for a refresh token on the backend.
        pub const AUTHORIZATION_CODE: AuthorizationType = AuthorizationType::new(1);

        /// Return an authorization code for a given Google+ page that can then be
        /// exchanged for a refresh token on the backend.
        pub const GOOGLE_PLUS_AUTHORIZATION_CODE: AuthorizationType = AuthorizationType::new(2);

        /// Use First Party OAuth.
        pub const FIRST_PARTY_OAUTH: AuthorizationType = AuthorizationType::new(3);

        /// Creates a new AuthorizationType instance.
        pub(crate) const fn new(value: i32) -> Self {
            Self(value)
        }

        /// Gets the enum value.
        pub fn value(&self) -> i32 {
            self.0
        }

        /// Gets the enum value as a string.
        pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
            match self.0 {
                0 => std::borrow::Cow::Borrowed("AUTHORIZATION_TYPE_UNSPECIFIED"),
                1 => std::borrow::Cow::Borrowed("AUTHORIZATION_CODE"),
                2 => std::borrow::Cow::Borrowed("GOOGLE_PLUS_AUTHORIZATION_CODE"),
                3 => std::borrow::Cow::Borrowed("FIRST_PARTY_OAUTH"),
                _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
            }
        }

        /// Creates an enum value from the value name.
        pub fn from_str_name(name: &str) -> std::option::Option<Self> {
            match name {
                "AUTHORIZATION_TYPE_UNSPECIFIED" => {
                    std::option::Option::Some(Self::AUTHORIZATION_TYPE_UNSPECIFIED)
                }
                "AUTHORIZATION_CODE" => std::option::Option::Some(Self::AUTHORIZATION_CODE),
                "GOOGLE_PLUS_AUTHORIZATION_CODE" => {
                    std::option::Option::Some(Self::GOOGLE_PLUS_AUTHORIZATION_CODE)
                }
                "FIRST_PARTY_OAUTH" => std::option::Option::Some(Self::FIRST_PARTY_OAUTH),
                _ => std::option::Option::None,
            }
        }
    }

    impl std::convert::From<i32> for AuthorizationType {
        fn from(value: i32) -> Self {
            Self::new(value)
        }
    }

    impl std::default::Default for AuthorizationType {
        fn default() -> Self {
            Self::new(0)
        }
    }

    /// Represents how the data source supports data auto refresh.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct DataRefreshType(i32);

    impl DataRefreshType {
        /// The data source won't support data auto refresh, which is default value.
        pub const DATA_REFRESH_TYPE_UNSPECIFIED: DataRefreshType = DataRefreshType::new(0);

        /// The data source supports data auto refresh, and runs will be scheduled
        /// for the past few days. Does not allow custom values to be set for each
        /// transfer config.
        pub const SLIDING_WINDOW: DataRefreshType = DataRefreshType::new(1);

        /// The data source supports data auto refresh, and runs will be scheduled
        /// for the past few days. Allows custom values to be set for each transfer
        /// config.
        pub const CUSTOM_SLIDING_WINDOW: DataRefreshType = DataRefreshType::new(2);

        /// Creates a new DataRefreshType instance.
        pub(crate) const fn new(value: i32) -> Self {
            Self(value)
        }

        /// Gets the enum value.
        pub fn value(&self) -> i32 {
            self.0
        }

        /// Gets the enum value as a string.
        pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
            match self.0 {
                0 => std::borrow::Cow::Borrowed("DATA_REFRESH_TYPE_UNSPECIFIED"),
                1 => std::borrow::Cow::Borrowed("SLIDING_WINDOW"),
                2 => std::borrow::Cow::Borrowed("CUSTOM_SLIDING_WINDOW"),
                _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
            }
        }

        /// Creates an enum value from the value name.
        pub fn from_str_name(name: &str) -> std::option::Option<Self> {
            match name {
                "DATA_REFRESH_TYPE_UNSPECIFIED" => {
                    std::option::Option::Some(Self::DATA_REFRESH_TYPE_UNSPECIFIED)
                }
                "SLIDING_WINDOW" => std::option::Option::Some(Self::SLIDING_WINDOW),
                "CUSTOM_SLIDING_WINDOW" => std::option::Option::Some(Self::CUSTOM_SLIDING_WINDOW),
                _ => std::option::Option::None,
            }
        }
    }

    impl std::convert::From<i32> for DataRefreshType {
        fn from(value: i32) -> Self {
            Self::new(value)
        }
    }

    impl std::default::Default for DataRefreshType {
        fn default() -> Self {
            Self::new(0)
        }
    }
}

/// A request to get data source info.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetDataSourceRequest {
    /// Required. The field will contain name of the resource requested, for
    /// example: `projects/{project_id}/dataSources/{data_source_id}` or
    /// `projects/{project_id}/locations/{location_id}/dataSources/{data_source_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetDataSourceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetDataSourceRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetDataSourceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.GetDataSourceRequest"
    }
}

/// Request to list supported data sources and their data transfer settings.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListDataSourcesRequest {
    /// Required. The BigQuery project id for which data sources should be
    /// returned. Must be in the form: `projects/{project_id}` or
    /// `projects/{project_id}/locations/{location_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Pagination token, which can be used to request a specific page
    /// of `ListDataSourcesRequest` list results. For multiple-page
    /// results, `ListDataSourcesResponse` outputs
    /// a `next_page` token, which can be used as the
    /// `page_token` value to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Page size. The default page size is the maximum value of 1000 results.
    pub page_size: i32,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListDataSourcesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListDataSourcesRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListDataSourcesRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListDataSourcesRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }
}

impl wkt::message::Message for ListDataSourcesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListDataSourcesRequest"
    }
}

/// Returns list of supported data sources and their metadata.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListDataSourcesResponse {
    /// List of supported data sources and their transfer settings.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub data_sources: std::vec::Vec<crate::model::DataSource>,

    /// Output only. The next-pagination token. For multiple-page list results,
    /// this token can be used as the
    /// `ListDataSourcesRequest.page_token`
    /// to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListDataSourcesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListDataSourcesResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [data_sources][crate::model::ListDataSourcesResponse::data_sources].
    pub fn set_data_sources<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DataSource>,
    {
        use std::iter::Iterator;
        self.data_sources = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListDataSourcesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListDataSourcesResponse"
    }
}

#[doc(hidden)]
impl gax::paginator::internal::PageableResponse for ListDataSourcesResponse {
    type PageItem = crate::model::DataSource;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.data_sources
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// A request to create a data transfer configuration. If new credentials are
/// needed for this transfer configuration, authorization info must be provided.
/// If authorization info is provided, the transfer configuration will be
/// associated with the user id corresponding to the authorization info.
/// Otherwise, the transfer configuration will be associated with the calling
/// user.
///
/// When using a cross project service account for creating a transfer config,
/// you must enable cross project service account usage. For more information,
/// see [Disable attachment of service accounts to resources in other
/// projects](https://cloud.google.com/resource-manager/docs/organization-policy/restricting-service-accounts#disable_cross_project_service_accounts).
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CreateTransferConfigRequest {
    /// Required. The BigQuery project id where the transfer configuration should
    /// be created. Must be in the format
    /// projects/{project_id}/locations/{location_id} or projects/{project_id}. If
    /// specified location and location of the destination bigquery dataset do not
    /// match - the request will fail.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Required. Data transfer configuration to create.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub transfer_config: std::option::Option<crate::model::TransferConfig>,

    /// Deprecated: Authorization code was required when
    /// `transferConfig.dataSourceId` is 'youtube_channel' but it is no longer used
    /// in any data sources. Use `version_info` instead.
    ///
    /// Optional OAuth2 authorization code to use with this transfer configuration.
    /// This is required only if `transferConfig.dataSourceId` is 'youtube_channel'
    /// and new credentials are needed, as indicated by `CheckValidCreds`. In order
    /// to obtain authorization_code, make a request to the following URL:
    ///
    /// * The \<var\>client_id\</var\> is the OAuth client_id of the data source as
    ///   returned by ListDataSources method.
    /// * \<var\>data_source_scopes\</var\> are the scopes returned by ListDataSources
    ///   method.
    ///
    /// Note that this should not be set when `service_account_name` is used to
    /// create the transfer config.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub authorization_code: std::string::String,

    /// Optional version info. This parameter replaces `authorization_code` which
    /// is no longer used in any data sources. This is required only if
    /// `transferConfig.dataSourceId` is 'youtube_channel' *or* new credentials
    /// are needed, as indicated by `CheckValidCreds`. In order to obtain version
    /// info, make a request to the following URL:
    ///
    /// * The \<var\>client_id\</var\> is the OAuth client_id of the data source as
    ///   returned by ListDataSources method.
    /// * \<var\>data_source_scopes\</var\> are the scopes returned by ListDataSources
    ///   method.
    ///
    /// Note that this should not be set when `service_account_name` is used to
    /// create the transfer config.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub version_info: std::string::String,

    /// Optional service account email. If this field is set, the transfer config
    /// will be created with this service account's credentials. It requires that
    /// the requesting user calling this API has permissions to act as this service
    /// account.
    ///
    /// Note that not all data sources support service account credentials when
    /// creating a transfer config. For the latest list of data sources, read about
    /// [using service
    /// accounts](https://cloud.google.com/bigquery-transfer/docs/use-service-accounts).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub service_account_name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateTransferConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateTransferConfigRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [transfer_config][crate::model::CreateTransferConfigRequest::transfer_config].
    pub fn set_transfer_config<
        T: std::convert::Into<std::option::Option<crate::model::TransferConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transfer_config = v.into();
        self
    }

    /// Sets the value of [authorization_code][crate::model::CreateTransferConfigRequest::authorization_code].
    pub fn set_authorization_code<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_code = v.into();
        self
    }

    /// Sets the value of [version_info][crate::model::CreateTransferConfigRequest::version_info].
    pub fn set_version_info<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version_info = v.into();
        self
    }

    /// Sets the value of [service_account_name][crate::model::CreateTransferConfigRequest::service_account_name].
    pub fn set_service_account_name<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.service_account_name = v.into();
        self
    }
}

impl wkt::message::Message for CreateTransferConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.CreateTransferConfigRequest"
    }
}

/// A request to update a transfer configuration. To update the user id of the
/// transfer configuration, authorization info needs to be provided.
///
/// When using a cross project service account for updating a transfer config,
/// you must enable cross project service account usage. For more information,
/// see [Disable attachment of service accounts to resources in other
/// projects](https://cloud.google.com/resource-manager/docs/organization-policy/restricting-service-accounts#disable_cross_project_service_accounts).
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UpdateTransferConfigRequest {
    /// Required. Data transfer configuration to create.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub transfer_config: std::option::Option<crate::model::TransferConfig>,

    /// Deprecated: Authorization code was required when
    /// `transferConfig.dataSourceId` is 'youtube_channel' but it is no longer used
    /// in any data sources. Use `version_info` instead.
    ///
    /// Optional OAuth2 authorization code to use with this transfer configuration.
    /// This is required only if `transferConfig.dataSourceId` is 'youtube_channel'
    /// and new credentials are needed, as indicated by `CheckValidCreds`. In order
    /// to obtain authorization_code, make a request to the following URL:
    ///
    /// * The \<var\>client_id\</var\> is the OAuth client_id of the data source as
    ///   returned by ListDataSources method.
    /// * \<var\>data_source_scopes\</var\> are the scopes returned by ListDataSources
    ///   method.
    ///
    /// Note that this should not be set when `service_account_name` is used to
    /// update the transfer config.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub authorization_code: std::string::String,

    /// Required. Required list of fields to be updated in this request.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Optional version info. This parameter replaces `authorization_code` which
    /// is no longer used in any data sources. This is required only if
    /// `transferConfig.dataSourceId` is 'youtube_channel' *or* new credentials
    /// are needed, as indicated by `CheckValidCreds`. In order to obtain version
    /// info, make a request to the following URL:
    ///
    /// * The \<var\>client_id\</var\> is the OAuth client_id of the data source as
    ///   returned by ListDataSources method.
    /// * \<var\>data_source_scopes\</var\> are the scopes returned by ListDataSources
    ///   method.
    ///
    /// Note that this should not be set when `service_account_name` is used to
    /// update the transfer config.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub version_info: std::string::String,

    /// Optional service account email. If this field is set, the transfer config
    /// will be created with this service account's credentials. It requires that
    /// the requesting user calling this API has permissions to act as this service
    /// account.
    ///
    /// Note that not all data sources support service account credentials when
    /// creating a transfer config. For the latest list of data sources, read about
    /// [using service
    /// accounts](https://cloud.google.com/bigquery-transfer/docs/use-service-accounts).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub service_account_name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateTransferConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [transfer_config][crate::model::UpdateTransferConfigRequest::transfer_config].
    pub fn set_transfer_config<
        T: std::convert::Into<std::option::Option<crate::model::TransferConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transfer_config = v.into();
        self
    }

    /// Sets the value of [authorization_code][crate::model::UpdateTransferConfigRequest::authorization_code].
    pub fn set_authorization_code<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_code = v.into();
        self
    }

    /// Sets the value of [update_mask][crate::model::UpdateTransferConfigRequest::update_mask].
    pub fn set_update_mask<T: std::convert::Into<std::option::Option<wkt::FieldMask>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_mask = v.into();
        self
    }

    /// Sets the value of [version_info][crate::model::UpdateTransferConfigRequest::version_info].
    pub fn set_version_info<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version_info = v.into();
        self
    }

    /// Sets the value of [service_account_name][crate::model::UpdateTransferConfigRequest::service_account_name].
    pub fn set_service_account_name<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.service_account_name = v.into();
        self
    }
}

impl wkt::message::Message for UpdateTransferConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.UpdateTransferConfigRequest"
    }
}

/// A request to get data transfer information.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetTransferConfigRequest {
    /// Required. The field will contain name of the resource requested, for
    /// example: `projects/{project_id}/transferConfigs/{config_id}` or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetTransferConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetTransferConfigRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetTransferConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.GetTransferConfigRequest"
    }
}

/// A request to delete data transfer information. All associated transfer runs
/// and log messages will be deleted as well.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DeleteTransferConfigRequest {
    /// Required. The field will contain name of the resource requested, for
    /// example: `projects/{project_id}/transferConfigs/{config_id}` or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteTransferConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteTransferConfigRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for DeleteTransferConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.DeleteTransferConfigRequest"
    }
}

/// A request to get data transfer run information.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetTransferRunRequest {
    /// Required. The field will contain name of the resource requested, for
    /// example: `projects/{project_id}/transferConfigs/{config_id}/runs/{run_id}`
    /// or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}/runs/{run_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetTransferRunRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetTransferRunRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetTransferRunRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.GetTransferRunRequest"
    }
}

/// A request to delete data transfer run information.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DeleteTransferRunRequest {
    /// Required. The field will contain name of the resource requested, for
    /// example: `projects/{project_id}/transferConfigs/{config_id}/runs/{run_id}`
    /// or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}/runs/{run_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteTransferRunRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteTransferRunRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for DeleteTransferRunRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.DeleteTransferRunRequest"
    }
}

/// A request to list data transfers configured for a BigQuery project.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListTransferConfigsRequest {
    /// Required. The BigQuery project id for which transfer configs
    /// should be returned: `projects/{project_id}` or
    /// `projects/{project_id}/locations/{location_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// When specified, only configurations of requested data sources are returned.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub data_source_ids: std::vec::Vec<std::string::String>,

    /// Pagination token, which can be used to request a specific page
    /// of `ListTransfersRequest` list results. For multiple-page
    /// results, `ListTransfersResponse` outputs
    /// a `next_page` token, which can be used as the
    /// `page_token` value to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Page size. The default page size is the maximum value of 1000 results.
    pub page_size: i32,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListTransferConfigsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListTransferConfigsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListTransferConfigsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListTransferConfigsRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [data_source_ids][crate::model::ListTransferConfigsRequest::data_source_ids].
    pub fn set_data_source_ids<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.data_source_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListTransferConfigsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListTransferConfigsRequest"
    }
}

/// The returned list of pipelines in the project.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListTransferConfigsResponse {
    /// Output only. The stored pipeline transfer configurations.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub transfer_configs: std::vec::Vec<crate::model::TransferConfig>,

    /// Output only. The next-pagination token. For multiple-page list results,
    /// this token can be used as the
    /// `ListTransferConfigsRequest.page_token`
    /// to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListTransferConfigsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListTransferConfigsResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [transfer_configs][crate::model::ListTransferConfigsResponse::transfer_configs].
    pub fn set_transfer_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TransferConfig>,
    {
        use std::iter::Iterator;
        self.transfer_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListTransferConfigsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListTransferConfigsResponse"
    }
}

#[doc(hidden)]
impl gax::paginator::internal::PageableResponse for ListTransferConfigsResponse {
    type PageItem = crate::model::TransferConfig;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.transfer_configs
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// A request to list data transfer runs.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListTransferRunsRequest {
    /// Required. Name of transfer configuration for which transfer runs should be
    /// retrieved. Format of transfer configuration resource name is:
    /// `projects/{project_id}/transferConfigs/{config_id}` or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// When specified, only transfer runs with requested states are returned.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub states: std::vec::Vec<crate::model::TransferState>,

    /// Pagination token, which can be used to request a specific page
    /// of `ListTransferRunsRequest` list results. For multiple-page
    /// results, `ListTransferRunsResponse` outputs
    /// a `next_page` token, which can be used as the
    /// `page_token` value to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Page size. The default page size is the maximum value of 1000 results.
    pub page_size: i32,

    /// Indicates how run attempts are to be pulled.
    pub run_attempt: crate::model::list_transfer_runs_request::RunAttempt,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListTransferRunsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListTransferRunsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListTransferRunsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListTransferRunsRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [run_attempt][crate::model::ListTransferRunsRequest::run_attempt].
    pub fn set_run_attempt<
        T: std::convert::Into<crate::model::list_transfer_runs_request::RunAttempt>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.run_attempt = v.into();
        self
    }

    /// Sets the value of [states][crate::model::ListTransferRunsRequest::states].
    pub fn set_states<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TransferState>,
    {
        use std::iter::Iterator;
        self.states = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListTransferRunsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListTransferRunsRequest"
    }
}

/// Defines additional types related to [ListTransferRunsRequest].
pub mod list_transfer_runs_request {
    #[allow(unused_imports)]
    use super::*;

    /// Represents which runs should be pulled.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct RunAttempt(i32);

    impl RunAttempt {
        /// All runs should be returned.
        pub const RUN_ATTEMPT_UNSPECIFIED: RunAttempt = RunAttempt::new(0);

        /// Only latest run per day should be returned.
        pub const LATEST: RunAttempt = RunAttempt::new(1);

        /// Creates a new RunAttempt instance.
        pub(crate) const fn new(value: i32) -> Self {
            Self(value)
        }

        /// Gets the enum value.
        pub fn value(&self) -> i32 {
            self.0
        }

        /// Gets the enum value as a string.
        pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
            match self.0 {
                0 => std::borrow::Cow::Borrowed("RUN_ATTEMPT_UNSPECIFIED"),
                1 => std::borrow::Cow::Borrowed("LATEST"),
                _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
            }
        }

        /// Creates an enum value from the value name.
        pub fn from_str_name(name: &str) -> std::option::Option<Self> {
            match name {
                "RUN_ATTEMPT_UNSPECIFIED" => {
                    std::option::Option::Some(Self::RUN_ATTEMPT_UNSPECIFIED)
                }
                "LATEST" => std::option::Option::Some(Self::LATEST),
                _ => std::option::Option::None,
            }
        }
    }

    impl std::convert::From<i32> for RunAttempt {
        fn from(value: i32) -> Self {
            Self::new(value)
        }
    }

    impl std::default::Default for RunAttempt {
        fn default() -> Self {
            Self::new(0)
        }
    }
}

/// The returned list of pipelines in the project.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListTransferRunsResponse {
    /// Output only. The stored pipeline transfer runs.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub transfer_runs: std::vec::Vec<crate::model::TransferRun>,

    /// Output only. The next-pagination token. For multiple-page list results,
    /// this token can be used as the
    /// `ListTransferRunsRequest.page_token`
    /// to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListTransferRunsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListTransferRunsResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [transfer_runs][crate::model::ListTransferRunsResponse::transfer_runs].
    pub fn set_transfer_runs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TransferRun>,
    {
        use std::iter::Iterator;
        self.transfer_runs = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListTransferRunsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListTransferRunsResponse"
    }
}

#[doc(hidden)]
impl gax::paginator::internal::PageableResponse for ListTransferRunsResponse {
    type PageItem = crate::model::TransferRun;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.transfer_runs
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// A request to get user facing log messages associated with data transfer run.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListTransferLogsRequest {
    /// Required. Transfer run name in the form:
    /// `projects/{project_id}/transferConfigs/{config_id}/runs/{run_id}` or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}/runs/{run_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Pagination token, which can be used to request a specific page
    /// of `ListTransferLogsRequest` list results. For multiple-page
    /// results, `ListTransferLogsResponse` outputs
    /// a `next_page` token, which can be used as the
    /// `page_token` value to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Page size. The default page size is the maximum value of 1000 results.
    pub page_size: i32,

    /// Message types to return. If not populated - INFO, WARNING and ERROR
    /// messages are returned.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub message_types: std::vec::Vec<crate::model::transfer_message::MessageSeverity>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListTransferLogsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListTransferLogsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListTransferLogsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListTransferLogsRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [message_types][crate::model::ListTransferLogsRequest::message_types].
    pub fn set_message_types<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::transfer_message::MessageSeverity>,
    {
        use std::iter::Iterator;
        self.message_types = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListTransferLogsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListTransferLogsRequest"
    }
}

/// The returned list transfer run messages.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListTransferLogsResponse {
    /// Output only. The stored pipeline transfer messages.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub transfer_messages: std::vec::Vec<crate::model::TransferMessage>,

    /// Output only. The next-pagination token. For multiple-page list results,
    /// this token can be used as the
    /// `GetTransferRunLogRequest.page_token`
    /// to request the next page of list results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListTransferLogsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListTransferLogsResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [transfer_messages][crate::model::ListTransferLogsResponse::transfer_messages].
    pub fn set_transfer_messages<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TransferMessage>,
    {
        use std::iter::Iterator;
        self.transfer_messages = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListTransferLogsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ListTransferLogsResponse"
    }
}

#[doc(hidden)]
impl gax::paginator::internal::PageableResponse for ListTransferLogsResponse {
    type PageItem = crate::model::TransferMessage;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.transfer_messages
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// A request to determine whether the user has valid credentials. This method
/// is used to limit the number of OAuth popups in the user interface. The
/// user id is inferred from the API call context.
/// If the data source has the Google+ authorization type, this method
/// returns false, as it cannot be determined whether the credentials are
/// already valid merely based on the user id.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CheckValidCredsRequest {
    /// Required. The data source in the form:
    /// `projects/{project_id}/dataSources/{data_source_id}` or
    /// `projects/{project_id}/locations/{location_id}/dataSources/{data_source_id}`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CheckValidCredsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::CheckValidCredsRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for CheckValidCredsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.CheckValidCredsRequest"
    }
}

/// A response indicating whether the credentials exist and are valid.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CheckValidCredsResponse {
    /// If set to `true`, the credentials exist and are valid.
    pub has_valid_creds: bool,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CheckValidCredsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [has_valid_creds][crate::model::CheckValidCredsResponse::has_valid_creds].
    pub fn set_has_valid_creds<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.has_valid_creds = v.into();
        self
    }
}

impl wkt::message::Message for CheckValidCredsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.CheckValidCredsResponse"
    }
}

/// A request to schedule transfer runs for a time range.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ScheduleTransferRunsRequest {
    /// Required. Transfer configuration name in the form:
    /// `projects/{project_id}/transferConfigs/{config_id}` or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Required. Start time of the range of transfer runs. For example,
    /// `"2017-05-25T00:00:00+00:00"`.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Required. End time of the range of transfer runs. For example,
    /// `"2017-05-30T00:00:00+00:00"`.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub end_time: std::option::Option<wkt::Timestamp>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ScheduleTransferRunsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ScheduleTransferRunsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::ScheduleTransferRunsRequest::start_time].
    pub fn set_start_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::ScheduleTransferRunsRequest::end_time].
    pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_time = v.into();
        self
    }
}

impl wkt::message::Message for ScheduleTransferRunsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ScheduleTransferRunsRequest"
    }
}

/// A response to schedule transfer runs for a time range.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ScheduleTransferRunsResponse {
    /// The transfer runs that were scheduled.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub runs: std::vec::Vec<crate::model::TransferRun>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ScheduleTransferRunsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [runs][crate::model::ScheduleTransferRunsResponse::runs].
    pub fn set_runs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TransferRun>,
    {
        use std::iter::Iterator;
        self.runs = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ScheduleTransferRunsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ScheduleTransferRunsResponse"
    }
}

/// A request to start manual transfer runs.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct StartManualTransferRunsRequest {
    /// Required. Transfer configuration name in the form:
    /// `projects/{project_id}/transferConfigs/{config_id}` or
    /// `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The requested time specification - this can be a time range or a specific
    /// run_time.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub time: std::option::Option<crate::model::start_manual_transfer_runs_request::Time>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl StartManualTransferRunsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::StartManualTransferRunsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [time][crate::model::StartManualTransferRunsRequest::time].
    ///
    /// Note that all the setters affecting `time` are mutually
    /// exclusive.
    pub fn set_time<
        T: std::convert::Into<
                std::option::Option<crate::model::start_manual_transfer_runs_request::Time>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.time = v.into();
        self
    }

    /// The value of [time][crate::model::StartManualTransferRunsRequest::time]
    /// if it holds a `RequestedTimeRange`, `None` if the field is not set or
    /// holds a different branch.
    pub fn requested_time_range(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::start_manual_transfer_runs_request::TimeRange>,
    > {
        #[allow(unreachable_patterns)]
        self.time.as_ref().and_then(|v| match v {
            crate::model::start_manual_transfer_runs_request::Time::RequestedTimeRange(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// The value of [time][crate::model::StartManualTransferRunsRequest::time]
    /// if it holds a `RequestedRunTime`, `None` if the field is not set or
    /// holds a different branch.
    pub fn requested_run_time(&self) -> std::option::Option<&std::boxed::Box<wkt::Timestamp>> {
        #[allow(unreachable_patterns)]
        self.time.as_ref().and_then(|v| match v {
            crate::model::start_manual_transfer_runs_request::Time::RequestedRunTime(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [time][crate::model::StartManualTransferRunsRequest::time]
    /// to hold a `RequestedTimeRange`.
    ///
    /// Note that all the setters affecting `time` are
    /// mutually exclusive.
    pub fn set_requested_time_range<
        T: std::convert::Into<
                std::boxed::Box<crate::model::start_manual_transfer_runs_request::TimeRange>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.time = std::option::Option::Some(
            crate::model::start_manual_transfer_runs_request::Time::RequestedTimeRange(v.into()),
        );
        self
    }

    /// Sets the value of [time][crate::model::StartManualTransferRunsRequest::time]
    /// to hold a `RequestedRunTime`.
    ///
    /// Note that all the setters affecting `time` are
    /// mutually exclusive.
    pub fn set_requested_run_time<T: std::convert::Into<std::boxed::Box<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.time = std::option::Option::Some(
            crate::model::start_manual_transfer_runs_request::Time::RequestedRunTime(v.into()),
        );
        self
    }
}

impl wkt::message::Message for StartManualTransferRunsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.StartManualTransferRunsRequest"
    }
}

/// Defines additional types related to [StartManualTransferRunsRequest].
pub mod start_manual_transfer_runs_request {
    #[allow(unused_imports)]
    use super::*;

    /// A specification for a time range, this will request transfer runs with
    /// run_time between start_time (inclusive) and end_time (exclusive).
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct TimeRange {
        /// Start time of the range of transfer runs. For example,
        /// `"2017-05-25T00:00:00+00:00"`. The start_time must be strictly less than
        /// the end_time. Creates transfer runs where run_time is in the range
        /// between start_time (inclusive) and end_time (exclusive).
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub start_time: std::option::Option<wkt::Timestamp>,

        /// End time of the range of transfer runs. For example,
        /// `"2017-05-30T00:00:00+00:00"`. The end_time must not be in the future.
        /// Creates transfer runs where run_time is in the range between start_time
        /// (inclusive) and end_time (exclusive).
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub end_time: std::option::Option<wkt::Timestamp>,

        #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl TimeRange {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [start_time][crate::model::start_manual_transfer_runs_request::TimeRange::start_time].
        pub fn set_start_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
            mut self,
            v: T,
        ) -> Self {
            self.start_time = v.into();
            self
        }

        /// Sets the value of [end_time][crate::model::start_manual_transfer_runs_request::TimeRange::end_time].
        pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
            mut self,
            v: T,
        ) -> Self {
            self.end_time = v.into();
            self
        }
    }

    impl wkt::message::Message for TimeRange {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.StartManualTransferRunsRequest.TimeRange"
        }
    }

    /// The requested time specification - this can be a time range or a specific
    /// run_time.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Time {
        /// A time_range start and end timestamp for historical data files or reports
        /// that are scheduled to be transferred by the scheduled transfer run.
        /// requested_time_range must be a past time and cannot include future time
        /// values.
        RequestedTimeRange(
            std::boxed::Box<crate::model::start_manual_transfer_runs_request::TimeRange>,
        ),
        /// A run_time timestamp for historical data files or reports
        /// that are scheduled to be transferred by the scheduled transfer run.
        /// requested_run_time must be a past time and cannot include future time
        /// values.
        RequestedRunTime(std::boxed::Box<wkt::Timestamp>),
    }
}

/// A response to start manual transfer runs.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct StartManualTransferRunsResponse {
    /// The transfer runs that were created.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub runs: std::vec::Vec<crate::model::TransferRun>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl StartManualTransferRunsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [runs][crate::model::StartManualTransferRunsResponse::runs].
    pub fn set_runs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TransferRun>,
    {
        use std::iter::Iterator;
        self.runs = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for StartManualTransferRunsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.StartManualTransferRunsResponse"
    }
}

/// A request to enroll a set of data sources so they are visible in the
/// BigQuery UI's `Transfer` tab.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct EnrollDataSourcesRequest {
    /// Required. The name of the project resource in the form:
    /// `projects/{project_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Data sources that are enrolled. It is required to provide at least one
    /// data source id.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub data_source_ids: std::vec::Vec<std::string::String>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnrollDataSourcesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::EnrollDataSourcesRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [data_source_ids][crate::model::EnrollDataSourcesRequest::data_source_ids].
    pub fn set_data_source_ids<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.data_source_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for EnrollDataSourcesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.EnrollDataSourcesRequest"
    }
}

/// A request to unenroll a set of data sources so they are no longer visible in
/// the BigQuery UI's `Transfer` tab.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UnenrollDataSourcesRequest {
    /// Required. The name of the project resource in the form:
    /// `projects/{project_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Data sources that are unenrolled. It is required to provide at least one
    /// data source id.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub data_source_ids: std::vec::Vec<std::string::String>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UnenrollDataSourcesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::UnenrollDataSourcesRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [data_source_ids][crate::model::UnenrollDataSourcesRequest::data_source_ids].
    pub fn set_data_source_ids<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.data_source_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for UnenrollDataSourcesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.UnenrollDataSourcesRequest"
    }
}

/// Represents preferences for sending email notifications for transfer run
/// events.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct EmailPreferences {
    /// If true, email notifications will be sent on transfer run failures.
    pub enable_failure_email: bool,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EmailPreferences {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_failure_email][crate::model::EmailPreferences::enable_failure_email].
    pub fn set_enable_failure_email<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_failure_email = v.into();
        self
    }
}

impl wkt::message::Message for EmailPreferences {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.EmailPreferences"
    }
}

/// Options customizing the data transfer schedule.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ScheduleOptions {
    /// If true, automatic scheduling of data transfer runs for this configuration
    /// will be disabled. The runs can be started on ad-hoc basis using
    /// StartManualTransferRuns API. When automatic scheduling is disabled, the
    /// TransferConfig.schedule field will be ignored.
    pub disable_auto_scheduling: bool,

    /// Specifies time to start scheduling transfer runs. The first run will be
    /// scheduled at or after the start time according to a recurrence pattern
    /// defined in the schedule string. The start time can be changed at any
    /// moment. The time when a data transfer can be triggered manually is not
    /// limited by this option.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Defines time to stop scheduling transfer runs. A transfer run cannot be
    /// scheduled at or after the end time. The end time can be changed at any
    /// moment. The time when a data transfer can be triggered manually is not
    /// limited by this option.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub end_time: std::option::Option<wkt::Timestamp>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ScheduleOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disable_auto_scheduling][crate::model::ScheduleOptions::disable_auto_scheduling].
    pub fn set_disable_auto_scheduling<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disable_auto_scheduling = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::ScheduleOptions::start_time].
    pub fn set_start_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::ScheduleOptions::end_time].
    pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_time = v.into();
        self
    }
}

impl wkt::message::Message for ScheduleOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ScheduleOptions"
    }
}

/// V2 options customizing different types of data transfer schedule.
/// This field supports existing time-based and manual transfer schedule. Also
/// supports Event-Driven transfer schedule. ScheduleOptionsV2 cannot be used
/// together with ScheduleOptions/Schedule.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ScheduleOptionsV2 {
    /// Data transfer schedules.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub schedule: std::option::Option<crate::model::schedule_options_v_2::Schedule>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ScheduleOptionsV2 {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [schedule][crate::model::ScheduleOptionsV2::schedule].
    ///
    /// Note that all the setters affecting `schedule` are mutually
    /// exclusive.
    pub fn set_schedule<
        T: std::convert::Into<std::option::Option<crate::model::schedule_options_v_2::Schedule>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schedule = v.into();
        self
    }

    /// The value of [schedule][crate::model::ScheduleOptionsV2::schedule]
    /// if it holds a `TimeBasedSchedule`, `None` if the field is not set or
    /// holds a different branch.
    pub fn time_based_schedule(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::TimeBasedSchedule>> {
        #[allow(unreachable_patterns)]
        self.schedule.as_ref().and_then(|v| match v {
            crate::model::schedule_options_v_2::Schedule::TimeBasedSchedule(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// The value of [schedule][crate::model::ScheduleOptionsV2::schedule]
    /// if it holds a `ManualSchedule`, `None` if the field is not set or
    /// holds a different branch.
    pub fn manual_schedule(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::ManualSchedule>> {
        #[allow(unreachable_patterns)]
        self.schedule.as_ref().and_then(|v| match v {
            crate::model::schedule_options_v_2::Schedule::ManualSchedule(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// The value of [schedule][crate::model::ScheduleOptionsV2::schedule]
    /// if it holds a `EventDrivenSchedule`, `None` if the field is not set or
    /// holds a different branch.
    pub fn event_driven_schedule(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::EventDrivenSchedule>> {
        #[allow(unreachable_patterns)]
        self.schedule.as_ref().and_then(|v| match v {
            crate::model::schedule_options_v_2::Schedule::EventDrivenSchedule(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [schedule][crate::model::ScheduleOptionsV2::schedule]
    /// to hold a `TimeBasedSchedule`.
    ///
    /// Note that all the setters affecting `schedule` are
    /// mutually exclusive.
    pub fn set_time_based_schedule<
        T: std::convert::Into<std::boxed::Box<crate::model::TimeBasedSchedule>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schedule = std::option::Option::Some(
            crate::model::schedule_options_v_2::Schedule::TimeBasedSchedule(v.into()),
        );
        self
    }

    /// Sets the value of [schedule][crate::model::ScheduleOptionsV2::schedule]
    /// to hold a `ManualSchedule`.
    ///
    /// Note that all the setters affecting `schedule` are
    /// mutually exclusive.
    pub fn set_manual_schedule<
        T: std::convert::Into<std::boxed::Box<crate::model::ManualSchedule>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schedule = std::option::Option::Some(
            crate::model::schedule_options_v_2::Schedule::ManualSchedule(v.into()),
        );
        self
    }

    /// Sets the value of [schedule][crate::model::ScheduleOptionsV2::schedule]
    /// to hold a `EventDrivenSchedule`.
    ///
    /// Note that all the setters affecting `schedule` are
    /// mutually exclusive.
    pub fn set_event_driven_schedule<
        T: std::convert::Into<std::boxed::Box<crate::model::EventDrivenSchedule>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schedule = std::option::Option::Some(
            crate::model::schedule_options_v_2::Schedule::EventDrivenSchedule(v.into()),
        );
        self
    }
}

impl wkt::message::Message for ScheduleOptionsV2 {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ScheduleOptionsV2"
    }
}

/// Defines additional types related to [ScheduleOptionsV2].
pub mod schedule_options_v_2 {
    #[allow(unused_imports)]
    use super::*;

    /// Data transfer schedules.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Schedule {
        /// Time based transfer schedule options. This is the default schedule
        /// option.
        TimeBasedSchedule(std::boxed::Box<crate::model::TimeBasedSchedule>),
        /// Manual transfer schedule. If set, the transfer run will not be
        /// auto-scheduled by the system, unless the client invokes
        /// StartManualTransferRuns.  This is equivalent to
        /// disable_auto_scheduling = true.
        ManualSchedule(std::boxed::Box<crate::model::ManualSchedule>),
        /// Event driven transfer schedule options. If set, the transfer will be
        /// scheduled upon events arrial.
        EventDrivenSchedule(std::boxed::Box<crate::model::EventDrivenSchedule>),
    }
}

/// Options customizing the time based transfer schedule.
/// Options are migrated from the original ScheduleOptions message.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct TimeBasedSchedule {
    /// Data transfer schedule.
    /// If the data source does not support a custom schedule, this should be
    /// empty. If it is empty, the default value for the data source will be used.
    /// The specified times are in UTC.
    /// Examples of valid format:
    /// `1st,3rd monday of month 15:30`,
    /// `every wed,fri of jan,jun 13:15`, and
    /// `first sunday of quarter 00:00`.
    /// See more explanation about the format here:
    /// <https://cloud.google.com/appengine/docs/flexible/python/scheduling-jobs-with-cron-yaml#the_schedule_format>
    ///
    /// NOTE: The minimum interval time between recurring transfers depends on the
    /// data source; refer to the documentation for your data source.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub schedule: std::string::String,

    /// Specifies time to start scheduling transfer runs. The first run will be
    /// scheduled at or after the start time according to a recurrence pattern
    /// defined in the schedule string. The start time can be changed at any
    /// moment.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Defines time to stop scheduling transfer runs. A transfer run cannot be
    /// scheduled at or after the end time. The end time can be changed at any
    /// moment.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub end_time: std::option::Option<wkt::Timestamp>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TimeBasedSchedule {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [schedule][crate::model::TimeBasedSchedule::schedule].
    pub fn set_schedule<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.schedule = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::TimeBasedSchedule::start_time].
    pub fn set_start_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::TimeBasedSchedule::end_time].
    pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_time = v.into();
        self
    }
}

impl wkt::message::Message for TimeBasedSchedule {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.TimeBasedSchedule"
    }
}

/// Options customizing manual transfers schedule.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ManualSchedule {
    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ManualSchedule {
    pub fn new() -> Self {
        std::default::Default::default()
    }
}

impl wkt::message::Message for ManualSchedule {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.ManualSchedule"
    }
}

/// Options customizing EventDriven transfers schedule.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct EventDrivenSchedule {
    /// Pub/Sub subscription name used to receive events.
    /// Only Google Cloud Storage data source support this option.
    /// Format: projects/{project}/subscriptions/{subscription}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub pubsub_subscription: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EventDrivenSchedule {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [pubsub_subscription][crate::model::EventDrivenSchedule::pubsub_subscription].
    pub fn set_pubsub_subscription<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.pubsub_subscription = v.into();
        self
    }
}

impl wkt::message::Message for EventDrivenSchedule {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.EventDrivenSchedule"
    }
}

/// Information about a user.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UserInfo {
    /// E-mail address of the user.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub email: std::option::Option<std::string::String>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UserInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [email][crate::model::UserInfo::email].
    pub fn set_email<T: std::convert::Into<std::option::Option<std::string::String>>>(
        mut self,
        v: T,
    ) -> Self {
        self.email = v.into();
        self
    }
}

impl wkt::message::Message for UserInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.UserInfo"
    }
}

/// Represents a data transfer configuration. A transfer configuration
/// contains all metadata needed to perform a data transfer. For example,
/// `destination_dataset_id` specifies where data should be stored.
/// When a new transfer configuration is created, the specified
/// `destination_dataset_id` is created when needed and shared with the
/// appropriate data source service account.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct TransferConfig {
    /// Identifier. The resource name of the transfer config.
    /// Transfer config names have the form either
    /// `projects/{project_id}/locations/{region}/transferConfigs/{config_id}` or
    /// `projects/{project_id}/transferConfigs/{config_id}`,
    /// where `config_id` is usually a UUID, even though it is not
    /// guaranteed or required. The name is ignored when creating a transfer
    /// config.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// User specified display name for the data transfer.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Data source ID. This cannot be changed once data transfer is created. The
    /// full list of available data source IDs can be returned through an API call:
    /// <https://cloud.google.com/bigquery-transfer/docs/reference/datatransfer/rest/v1/projects.locations.dataSources/list>
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub data_source_id: std::string::String,

    /// Parameters specific to each data source. For more information see the
    /// bq tab in the 'Setting up a data transfer' section for each data source.
    /// For example the parameters for Cloud Storage transfers are listed here:
    /// <https://cloud.google.com/bigquery-transfer/docs/cloud-storage-transfer#bq>
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub params: std::option::Option<wkt::Struct>,

    /// Data transfer schedule.
    /// If the data source does not support a custom schedule, this should be
    /// empty. If it is empty, the default value for the data source will be used.
    /// The specified times are in UTC.
    /// Examples of valid format:
    /// `1st,3rd monday of month 15:30`,
    /// `every wed,fri of jan,jun 13:15`, and
    /// `first sunday of quarter 00:00`.
    /// See more explanation about the format here:
    /// <https://cloud.google.com/appengine/docs/flexible/python/scheduling-jobs-with-cron-yaml#the_schedule_format>
    ///
    /// NOTE: The minimum interval time between recurring transfers depends on the
    /// data source; refer to the documentation for your data source.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub schedule: std::string::String,

    /// Options customizing the data transfer schedule.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub schedule_options: std::option::Option<crate::model::ScheduleOptions>,

    /// Options customizing different types of data transfer schedule.
    /// This field replaces "schedule" and "schedule_options" fields.
    /// ScheduleOptionsV2 cannot be used together with ScheduleOptions/Schedule.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub schedule_options_v2: std::option::Option<crate::model::ScheduleOptionsV2>,

    /// The number of days to look back to automatically refresh the data.
    /// For example, if `data_refresh_window_days = 10`, then every day
    /// BigQuery reingests data for [today-10, today-1], rather than ingesting data
    /// for just [today-1].
    /// Only valid if the data source supports the feature. Set the value to 0
    /// to use the default value.
    pub data_refresh_window_days: i32,

    /// Is this config disabled. When set to true, no runs will be scheduled for
    /// this transfer config.
    pub disabled: bool,

    /// Output only. Data transfer modification time. Ignored by server on input.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Next time when data transfer will run.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub next_run_time: std::option::Option<wkt::Timestamp>,

    /// Output only. State of the most recently updated transfer run.
    pub state: crate::model::TransferState,

    /// Deprecated. Unique ID of the user on whose behalf transfer is done.
    #[serde_as(as = "serde_with::DisplayFromStr")]
    pub user_id: i64,

    /// Output only. Region in which BigQuery dataset is located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub dataset_region: std::string::String,

    /// Pub/Sub topic where notifications will be sent after transfer runs
    /// associated with this transfer config finish.
    ///
    /// The format for specifying a pubsub topic is:
    /// `projects/{project_id}/topics/{topic_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub notification_pubsub_topic: std::string::String,

    /// Email notifications will be sent according to these preferences
    /// to the email address of the user who owns this transfer config.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub email_preferences: std::option::Option<crate::model::EmailPreferences>,

    /// Output only. Information about the user whose credentials are used to
    /// transfer data. Populated only for `transferConfigs.get` requests. In case
    /// the user information is not available, this field will not be populated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub owner_info: std::option::Option<crate::model::UserInfo>,

    /// The encryption configuration part. Currently, it is only used for the
    /// optional KMS key name. The BigQuery service account of your project must be
    /// granted permissions to use the key. Read methods will return the key name
    /// applied in effect. Write methods will apply the key if it is present, or
    /// otherwise try to apply project default keys if it is absent.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub encryption_configuration: std::option::Option<crate::model::EncryptionConfiguration>,

    /// Output only. Error code with detailed information about reason of the
    /// latest config failure.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub error: std::option::Option<rpc::model::Status>,

    /// The desination of the transfer config.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub destination: std::option::Option<crate::model::transfer_config::Destination>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TransferConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::TransferConfig::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::TransferConfig::display_name].
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [data_source_id][crate::model::TransferConfig::data_source_id].
    pub fn set_data_source_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.data_source_id = v.into();
        self
    }

    /// Sets the value of [params][crate::model::TransferConfig::params].
    pub fn set_params<T: std::convert::Into<std::option::Option<wkt::Struct>>>(
        mut self,
        v: T,
    ) -> Self {
        self.params = v.into();
        self
    }

    /// Sets the value of [schedule][crate::model::TransferConfig::schedule].
    pub fn set_schedule<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.schedule = v.into();
        self
    }

    /// Sets the value of [schedule_options][crate::model::TransferConfig::schedule_options].
    pub fn set_schedule_options<
        T: std::convert::Into<std::option::Option<crate::model::ScheduleOptions>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schedule_options = v.into();
        self
    }

    /// Sets the value of [schedule_options_v2][crate::model::TransferConfig::schedule_options_v2].
    pub fn set_schedule_options_v2<
        T: std::convert::Into<std::option::Option<crate::model::ScheduleOptionsV2>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schedule_options_v2 = v.into();
        self
    }

    /// Sets the value of [data_refresh_window_days][crate::model::TransferConfig::data_refresh_window_days].
    pub fn set_data_refresh_window_days<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.data_refresh_window_days = v.into();
        self
    }

    /// Sets the value of [disabled][crate::model::TransferConfig::disabled].
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::TransferConfig::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [next_run_time][crate::model::TransferConfig::next_run_time].
    pub fn set_next_run_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.next_run_time = v.into();
        self
    }

    /// Sets the value of [state][crate::model::TransferConfig::state].
    pub fn set_state<T: std::convert::Into<crate::model::TransferState>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [user_id][crate::model::TransferConfig::user_id].
    pub fn set_user_id<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.user_id = v.into();
        self
    }

    /// Sets the value of [dataset_region][crate::model::TransferConfig::dataset_region].
    pub fn set_dataset_region<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.dataset_region = v.into();
        self
    }

    /// Sets the value of [notification_pubsub_topic][crate::model::TransferConfig::notification_pubsub_topic].
    pub fn set_notification_pubsub_topic<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.notification_pubsub_topic = v.into();
        self
    }

    /// Sets the value of [email_preferences][crate::model::TransferConfig::email_preferences].
    pub fn set_email_preferences<
        T: std::convert::Into<std::option::Option<crate::model::EmailPreferences>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.email_preferences = v.into();
        self
    }

    /// Sets the value of [owner_info][crate::model::TransferConfig::owner_info].
    pub fn set_owner_info<T: std::convert::Into<std::option::Option<crate::model::UserInfo>>>(
        mut self,
        v: T,
    ) -> Self {
        self.owner_info = v.into();
        self
    }

    /// Sets the value of [encryption_configuration][crate::model::TransferConfig::encryption_configuration].
    pub fn set_encryption_configuration<
        T: std::convert::Into<std::option::Option<crate::model::EncryptionConfiguration>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.encryption_configuration = v.into();
        self
    }

    /// Sets the value of [error][crate::model::TransferConfig::error].
    pub fn set_error<T: std::convert::Into<std::option::Option<rpc::model::Status>>>(
        mut self,
        v: T,
    ) -> Self {
        self.error = v.into();
        self
    }

    /// Sets the value of [destination][crate::model::TransferConfig::destination].
    ///
    /// Note that all the setters affecting `destination` are mutually
    /// exclusive.
    pub fn set_destination<
        T: std::convert::Into<std::option::Option<crate::model::transfer_config::Destination>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = v.into();
        self
    }

    /// The value of [destination][crate::model::TransferConfig::destination]
    /// if it holds a `DestinationDatasetId`, `None` if the field is not set or
    /// holds a different branch.
    pub fn destination_dataset_id(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.destination.as_ref().and_then(|v| match v {
            crate::model::transfer_config::Destination::DestinationDatasetId(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [destination][crate::model::TransferConfig::destination]
    /// to hold a `DestinationDatasetId`.
    ///
    /// Note that all the setters affecting `destination` are
    /// mutually exclusive.
    pub fn set_destination_dataset_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.destination = std::option::Option::Some(
            crate::model::transfer_config::Destination::DestinationDatasetId(v.into()),
        );
        self
    }
}

impl wkt::message::Message for TransferConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.TransferConfig"
    }
}

/// Defines additional types related to [TransferConfig].
pub mod transfer_config {
    #[allow(unused_imports)]
    use super::*;

    /// The desination of the transfer config.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Destination {
        /// The BigQuery target dataset id.
        DestinationDatasetId(std::string::String),
    }
}

/// Represents the encryption configuration for a transfer.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct EncryptionConfiguration {
    /// The name of the KMS key used for encrypting BigQuery data.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub kms_key_name: std::option::Option<wkt::StringValue>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EncryptionConfiguration {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [kms_key_name][crate::model::EncryptionConfiguration::kms_key_name].
    pub fn set_kms_key_name<T: std::convert::Into<std::option::Option<wkt::StringValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.kms_key_name = v.into();
        self
    }
}

impl wkt::message::Message for EncryptionConfiguration {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.EncryptionConfiguration"
    }
}

/// Represents a data transfer run.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct TransferRun {
    /// Identifier. The resource name of the transfer run.
    /// Transfer run names have the form
    /// `projects/{project_id}/locations/{location}/transferConfigs/{config_id}/runs/{run_id}`.
    /// The name is ignored when creating a transfer run.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Minimum time after which a transfer run can be started.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub schedule_time: std::option::Option<wkt::Timestamp>,

    /// For batch transfer runs, specifies the date and time of the data should be
    /// ingested.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub run_time: std::option::Option<wkt::Timestamp>,

    /// Status of the transfer run.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub error_status: std::option::Option<rpc::model::Status>,

    /// Output only. Time when transfer run was started.
    /// Parameter ignored by server for input requests.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when transfer run ended.
    /// Parameter ignored by server for input requests.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Last time the data transfer run state was updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Parameters specific to each data source. For more information
    /// see the bq tab in the 'Setting up a data transfer' section for each data
    /// source. For example the parameters for Cloud Storage transfers are listed
    /// here:
    /// <https://cloud.google.com/bigquery-transfer/docs/cloud-storage-transfer#bq>
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub params: std::option::Option<wkt::Struct>,

    /// Output only. Data source id.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub data_source_id: std::string::String,

    /// Data transfer run state. Ignored for input requests.
    pub state: crate::model::TransferState,

    /// Deprecated. Unique ID of the user on whose behalf transfer is done.
    #[serde_as(as = "serde_with::DisplayFromStr")]
    pub user_id: i64,

    /// Output only. Describes the schedule of this transfer run if it was
    /// created as part of a regular schedule. For batch transfer runs that are
    /// scheduled manually, this is empty.
    /// NOTE: the system might choose to delay the schedule depending on the
    /// current load, so `schedule_time` doesn't always match this.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub schedule: std::string::String,

    /// Output only. Pub/Sub topic where a notification will be sent after this
    /// transfer run finishes.
    ///
    /// The format for specifying a pubsub topic is:
    /// `projects/{project_id}/topics/{topic_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub notification_pubsub_topic: std::string::String,

    /// Output only. Email notifications will be sent according to these
    /// preferences to the email address of the user who owns the transfer config
    /// this run was derived from.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub email_preferences: std::option::Option<crate::model::EmailPreferences>,

    /// Data transfer destination.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub destination: std::option::Option<crate::model::transfer_run::Destination>,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TransferRun {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::TransferRun::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [schedule_time][crate::model::TransferRun::schedule_time].
    pub fn set_schedule_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.schedule_time = v.into();
        self
    }

    /// Sets the value of [run_time][crate::model::TransferRun::run_time].
    pub fn set_run_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.run_time = v.into();
        self
    }

    /// Sets the value of [error_status][crate::model::TransferRun::error_status].
    pub fn set_error_status<T: std::convert::Into<std::option::Option<rpc::model::Status>>>(
        mut self,
        v: T,
    ) -> Self {
        self.error_status = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::TransferRun::start_time].
    pub fn set_start_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::TransferRun::end_time].
    pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::TransferRun::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [params][crate::model::TransferRun::params].
    pub fn set_params<T: std::convert::Into<std::option::Option<wkt::Struct>>>(
        mut self,
        v: T,
    ) -> Self {
        self.params = v.into();
        self
    }

    /// Sets the value of [data_source_id][crate::model::TransferRun::data_source_id].
    pub fn set_data_source_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.data_source_id = v.into();
        self
    }

    /// Sets the value of [state][crate::model::TransferRun::state].
    pub fn set_state<T: std::convert::Into<crate::model::TransferState>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [user_id][crate::model::TransferRun::user_id].
    pub fn set_user_id<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.user_id = v.into();
        self
    }

    /// Sets the value of [schedule][crate::model::TransferRun::schedule].
    pub fn set_schedule<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.schedule = v.into();
        self
    }

    /// Sets the value of [notification_pubsub_topic][crate::model::TransferRun::notification_pubsub_topic].
    pub fn set_notification_pubsub_topic<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.notification_pubsub_topic = v.into();
        self
    }

    /// Sets the value of [email_preferences][crate::model::TransferRun::email_preferences].
    pub fn set_email_preferences<
        T: std::convert::Into<std::option::Option<crate::model::EmailPreferences>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.email_preferences = v.into();
        self
    }

    /// Sets the value of [destination][crate::model::TransferRun::destination].
    ///
    /// Note that all the setters affecting `destination` are mutually
    /// exclusive.
    pub fn set_destination<
        T: std::convert::Into<std::option::Option<crate::model::transfer_run::Destination>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = v.into();
        self
    }

    /// The value of [destination][crate::model::TransferRun::destination]
    /// if it holds a `DestinationDatasetId`, `None` if the field is not set or
    /// holds a different branch.
    pub fn destination_dataset_id(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.destination.as_ref().and_then(|v| match v {
            crate::model::transfer_run::Destination::DestinationDatasetId(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [destination][crate::model::TransferRun::destination]
    /// to hold a `DestinationDatasetId`.
    ///
    /// Note that all the setters affecting `destination` are
    /// mutually exclusive.
    pub fn set_destination_dataset_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.destination = std::option::Option::Some(
            crate::model::transfer_run::Destination::DestinationDatasetId(v.into()),
        );
        self
    }
}

impl wkt::message::Message for TransferRun {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.TransferRun"
    }
}

/// Defines additional types related to [TransferRun].
pub mod transfer_run {
    #[allow(unused_imports)]
    use super::*;

    /// Data transfer destination.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Destination {
        /// Output only. The BigQuery target dataset id.
        DestinationDatasetId(std::string::String),
    }
}

/// Represents a user facing message for a particular data transfer run.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct TransferMessage {
    /// Time when message was logged.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub message_time: std::option::Option<wkt::Timestamp>,

    /// Message severity.
    pub severity: crate::model::transfer_message::MessageSeverity,

    /// Message text.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub message_text: std::string::String,

    #[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TransferMessage {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message_time][crate::model::TransferMessage::message_time].
    pub fn set_message_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.message_time = v.into();
        self
    }

    /// Sets the value of [severity][crate::model::TransferMessage::severity].
    pub fn set_severity<T: std::convert::Into<crate::model::transfer_message::MessageSeverity>>(
        mut self,
        v: T,
    ) -> Self {
        self.severity = v.into();
        self
    }

    /// Sets the value of [message_text][crate::model::TransferMessage::message_text].
    pub fn set_message_text<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.message_text = v.into();
        self
    }
}

impl wkt::message::Message for TransferMessage {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.datatransfer.v1.TransferMessage"
    }
}

/// Defines additional types related to [TransferMessage].
pub mod transfer_message {
    #[allow(unused_imports)]
    use super::*;

    /// Represents data transfer user facing message severity.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct MessageSeverity(i32);

    impl MessageSeverity {
        /// No severity specified.
        pub const MESSAGE_SEVERITY_UNSPECIFIED: MessageSeverity = MessageSeverity::new(0);

        /// Informational message.
        pub const INFO: MessageSeverity = MessageSeverity::new(1);

        /// Warning message.
        pub const WARNING: MessageSeverity = MessageSeverity::new(2);

        /// Error message.
        pub const ERROR: MessageSeverity = MessageSeverity::new(3);

        /// Creates a new MessageSeverity instance.
        pub(crate) const fn new(value: i32) -> Self {
            Self(value)
        }

        /// Gets the enum value.
        pub fn value(&self) -> i32 {
            self.0
        }

        /// Gets the enum value as a string.
        pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
            match self.0 {
                0 => std::borrow::Cow::Borrowed("MESSAGE_SEVERITY_UNSPECIFIED"),
                1 => std::borrow::Cow::Borrowed("INFO"),
                2 => std::borrow::Cow::Borrowed("WARNING"),
                3 => std::borrow::Cow::Borrowed("ERROR"),
                _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
            }
        }

        /// Creates an enum value from the value name.
        pub fn from_str_name(name: &str) -> std::option::Option<Self> {
            match name {
                "MESSAGE_SEVERITY_UNSPECIFIED" => {
                    std::option::Option::Some(Self::MESSAGE_SEVERITY_UNSPECIFIED)
                }
                "INFO" => std::option::Option::Some(Self::INFO),
                "WARNING" => std::option::Option::Some(Self::WARNING),
                "ERROR" => std::option::Option::Some(Self::ERROR),
                _ => std::option::Option::None,
            }
        }
    }

    impl std::convert::From<i32> for MessageSeverity {
        fn from(value: i32) -> Self {
            Self::new(value)
        }
    }

    impl std::default::Default for MessageSeverity {
        fn default() -> Self {
            Self::new(0)
        }
    }
}

/// DEPRECATED. Represents data transfer type.
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct TransferType(i32);

impl TransferType {
    /// Invalid or Unknown transfer type placeholder.
    pub const TRANSFER_TYPE_UNSPECIFIED: TransferType = TransferType::new(0);

    /// Batch data transfer.
    pub const BATCH: TransferType = TransferType::new(1);

    /// Streaming data transfer. Streaming data source currently doesn't
    /// support multiple transfer configs per project.
    pub const STREAMING: TransferType = TransferType::new(2);

    /// Creates a new TransferType instance.
    pub(crate) const fn new(value: i32) -> Self {
        Self(value)
    }

    /// Gets the enum value.
    pub fn value(&self) -> i32 {
        self.0
    }

    /// Gets the enum value as a string.
    pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
        match self.0 {
            0 => std::borrow::Cow::Borrowed("TRANSFER_TYPE_UNSPECIFIED"),
            1 => std::borrow::Cow::Borrowed("BATCH"),
            2 => std::borrow::Cow::Borrowed("STREAMING"),
            _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
        }
    }

    /// Creates an enum value from the value name.
    pub fn from_str_name(name: &str) -> std::option::Option<Self> {
        match name {
            "TRANSFER_TYPE_UNSPECIFIED" => {
                std::option::Option::Some(Self::TRANSFER_TYPE_UNSPECIFIED)
            }
            "BATCH" => std::option::Option::Some(Self::BATCH),
            "STREAMING" => std::option::Option::Some(Self::STREAMING),
            _ => std::option::Option::None,
        }
    }
}

impl std::convert::From<i32> for TransferType {
    fn from(value: i32) -> Self {
        Self::new(value)
    }
}

impl std::default::Default for TransferType {
    fn default() -> Self {
        Self::new(0)
    }
}

/// Represents data transfer run state.
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct TransferState(i32);

impl TransferState {
    /// State placeholder (0).
    pub const TRANSFER_STATE_UNSPECIFIED: TransferState = TransferState::new(0);

    /// Data transfer is scheduled and is waiting to be picked up by
    /// data transfer backend (2).
    pub const PENDING: TransferState = TransferState::new(2);

    /// Data transfer is in progress (3).
    pub const RUNNING: TransferState = TransferState::new(3);

    /// Data transfer completed successfully (4).
    pub const SUCCEEDED: TransferState = TransferState::new(4);

    /// Data transfer failed (5).
    pub const FAILED: TransferState = TransferState::new(5);

    /// Data transfer is cancelled (6).
    pub const CANCELLED: TransferState = TransferState::new(6);

    /// Creates a new TransferState instance.
    pub(crate) const fn new(value: i32) -> Self {
        Self(value)
    }

    /// Gets the enum value.
    pub fn value(&self) -> i32 {
        self.0
    }

    /// Gets the enum value as a string.
    pub fn as_str_name(&self) -> std::borrow::Cow<'static, str> {
        match self.0 {
            0 => std::borrow::Cow::Borrowed("TRANSFER_STATE_UNSPECIFIED"),
            2 => std::borrow::Cow::Borrowed("PENDING"),
            3 => std::borrow::Cow::Borrowed("RUNNING"),
            4 => std::borrow::Cow::Borrowed("SUCCEEDED"),
            5 => std::borrow::Cow::Borrowed("FAILED"),
            6 => std::borrow::Cow::Borrowed("CANCELLED"),
            _ => std::borrow::Cow::Owned(std::format!("UNKNOWN-VALUE:{}", self.0)),
        }
    }

    /// Creates an enum value from the value name.
    pub fn from_str_name(name: &str) -> std::option::Option<Self> {
        match name {
            "TRANSFER_STATE_UNSPECIFIED" => {
                std::option::Option::Some(Self::TRANSFER_STATE_UNSPECIFIED)
            }
            "PENDING" => std::option::Option::Some(Self::PENDING),
            "RUNNING" => std::option::Option::Some(Self::RUNNING),
            "SUCCEEDED" => std::option::Option::Some(Self::SUCCEEDED),
            "FAILED" => std::option::Option::Some(Self::FAILED),
            "CANCELLED" => std::option::Option::Some(Self::CANCELLED),
            _ => std::option::Option::None,
        }
    }
}

impl std::convert::From<i32> for TransferState {
    fn from(value: i32) -> Self {
        Self::new(value)
    }
}

impl std::default::Default for TransferState {
    fn default() -> Self {
        Self::new(0)
    }
}