#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateMeetingRoomConfiguration {
pub room_utilization_metrics_enabled: std::option::Option<bool>,
pub end_of_meeting_reminder: std::option::Option<crate::model::UpdateEndOfMeetingReminder>,
pub instant_booking: std::option::Option<crate::model::UpdateInstantBooking>,
pub require_check_in: std::option::Option<crate::model::UpdateRequireCheckIn>,
}
impl UpdateMeetingRoomConfiguration {
pub fn room_utilization_metrics_enabled(&self) -> std::option::Option<bool> {
self.room_utilization_metrics_enabled
}
pub fn end_of_meeting_reminder(
&self,
) -> std::option::Option<&crate::model::UpdateEndOfMeetingReminder> {
self.end_of_meeting_reminder.as_ref()
}
pub fn instant_booking(&self) -> std::option::Option<&crate::model::UpdateInstantBooking> {
self.instant_booking.as_ref()
}
pub fn require_check_in(&self) -> std::option::Option<&crate::model::UpdateRequireCheckIn> {
self.require_check_in.as_ref()
}
}
impl std::fmt::Debug for UpdateMeetingRoomConfiguration {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateMeetingRoomConfiguration");
formatter.field(
"room_utilization_metrics_enabled",
&self.room_utilization_metrics_enabled,
);
formatter.field("end_of_meeting_reminder", &self.end_of_meeting_reminder);
formatter.field("instant_booking", &self.instant_booking);
formatter.field("require_check_in", &self.require_check_in);
formatter.finish()
}
}
pub mod update_meeting_room_configuration {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_utilization_metrics_enabled: std::option::Option<bool>,
pub(crate) end_of_meeting_reminder:
std::option::Option<crate::model::UpdateEndOfMeetingReminder>,
pub(crate) instant_booking: std::option::Option<crate::model::UpdateInstantBooking>,
pub(crate) require_check_in: std::option::Option<crate::model::UpdateRequireCheckIn>,
}
impl Builder {
pub fn room_utilization_metrics_enabled(mut self, input: bool) -> Self {
self.room_utilization_metrics_enabled = Some(input);
self
}
pub fn set_room_utilization_metrics_enabled(
mut self,
input: std::option::Option<bool>,
) -> Self {
self.room_utilization_metrics_enabled = input;
self
}
pub fn end_of_meeting_reminder(
mut self,
input: crate::model::UpdateEndOfMeetingReminder,
) -> Self {
self.end_of_meeting_reminder = Some(input);
self
}
pub fn set_end_of_meeting_reminder(
mut self,
input: std::option::Option<crate::model::UpdateEndOfMeetingReminder>,
) -> Self {
self.end_of_meeting_reminder = input;
self
}
pub fn instant_booking(mut self, input: crate::model::UpdateInstantBooking) -> Self {
self.instant_booking = Some(input);
self
}
pub fn set_instant_booking(
mut self,
input: std::option::Option<crate::model::UpdateInstantBooking>,
) -> Self {
self.instant_booking = input;
self
}
pub fn require_check_in(mut self, input: crate::model::UpdateRequireCheckIn) -> Self {
self.require_check_in = Some(input);
self
}
pub fn set_require_check_in(
mut self,
input: std::option::Option<crate::model::UpdateRequireCheckIn>,
) -> Self {
self.require_check_in = input;
self
}
pub fn build(self) -> crate::model::UpdateMeetingRoomConfiguration {
crate::model::UpdateMeetingRoomConfiguration {
room_utilization_metrics_enabled: self.room_utilization_metrics_enabled,
end_of_meeting_reminder: self.end_of_meeting_reminder,
instant_booking: self.instant_booking,
require_check_in: self.require_check_in,
}
}
}
}
impl UpdateMeetingRoomConfiguration {
pub fn builder() -> crate::model::update_meeting_room_configuration::Builder {
crate::model::update_meeting_room_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateRequireCheckIn {
pub release_after_minutes: std::option::Option<i32>,
pub enabled: std::option::Option<bool>,
}
impl UpdateRequireCheckIn {
pub fn release_after_minutes(&self) -> std::option::Option<i32> {
self.release_after_minutes
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for UpdateRequireCheckIn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateRequireCheckIn");
formatter.field("release_after_minutes", &self.release_after_minutes);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod update_require_check_in {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) release_after_minutes: std::option::Option<i32>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn release_after_minutes(mut self, input: i32) -> Self {
self.release_after_minutes = Some(input);
self
}
pub fn set_release_after_minutes(mut self, input: std::option::Option<i32>) -> Self {
self.release_after_minutes = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::UpdateRequireCheckIn {
crate::model::UpdateRequireCheckIn {
release_after_minutes: self.release_after_minutes,
enabled: self.enabled,
}
}
}
}
impl UpdateRequireCheckIn {
pub fn builder() -> crate::model::update_require_check_in::Builder {
crate::model::update_require_check_in::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateInstantBooking {
pub duration_in_minutes: std::option::Option<i32>,
pub enabled: std::option::Option<bool>,
}
impl UpdateInstantBooking {
pub fn duration_in_minutes(&self) -> std::option::Option<i32> {
self.duration_in_minutes
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for UpdateInstantBooking {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateInstantBooking");
formatter.field("duration_in_minutes", &self.duration_in_minutes);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod update_instant_booking {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) duration_in_minutes: std::option::Option<i32>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn duration_in_minutes(mut self, input: i32) -> Self {
self.duration_in_minutes = Some(input);
self
}
pub fn set_duration_in_minutes(mut self, input: std::option::Option<i32>) -> Self {
self.duration_in_minutes = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::UpdateInstantBooking {
crate::model::UpdateInstantBooking {
duration_in_minutes: self.duration_in_minutes,
enabled: self.enabled,
}
}
}
}
impl UpdateInstantBooking {
pub fn builder() -> crate::model::update_instant_booking::Builder {
crate::model::update_instant_booking::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateEndOfMeetingReminder {
pub reminder_at_minutes: std::option::Option<std::vec::Vec<i32>>,
pub reminder_type: std::option::Option<crate::model::EndOfMeetingReminderType>,
pub enabled: std::option::Option<bool>,
}
impl UpdateEndOfMeetingReminder {
pub fn reminder_at_minutes(&self) -> std::option::Option<&[i32]> {
self.reminder_at_minutes.as_deref()
}
pub fn reminder_type(&self) -> std::option::Option<&crate::model::EndOfMeetingReminderType> {
self.reminder_type.as_ref()
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for UpdateEndOfMeetingReminder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateEndOfMeetingReminder");
formatter.field("reminder_at_minutes", &self.reminder_at_minutes);
formatter.field("reminder_type", &self.reminder_type);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod update_end_of_meeting_reminder {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) reminder_at_minutes: std::option::Option<std::vec::Vec<i32>>,
pub(crate) reminder_type: std::option::Option<crate::model::EndOfMeetingReminderType>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn reminder_at_minutes(mut self, input: impl Into<i32>) -> Self {
let mut v = self.reminder_at_minutes.unwrap_or_default();
v.push(input.into());
self.reminder_at_minutes = Some(v);
self
}
pub fn set_reminder_at_minutes(
mut self,
input: std::option::Option<std::vec::Vec<i32>>,
) -> Self {
self.reminder_at_minutes = input;
self
}
pub fn reminder_type(mut self, input: crate::model::EndOfMeetingReminderType) -> Self {
self.reminder_type = Some(input);
self
}
pub fn set_reminder_type(
mut self,
input: std::option::Option<crate::model::EndOfMeetingReminderType>,
) -> Self {
self.reminder_type = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::UpdateEndOfMeetingReminder {
crate::model::UpdateEndOfMeetingReminder {
reminder_at_minutes: self.reminder_at_minutes,
reminder_type: self.reminder_type,
enabled: self.enabled,
}
}
}
}
impl UpdateEndOfMeetingReminder {
pub fn builder() -> crate::model::update_end_of_meeting_reminder::Builder {
crate::model::update_end_of_meeting_reminder::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum EndOfMeetingReminderType {
#[allow(missing_docs)] AnnouncementTimeCheck,
#[allow(missing_docs)] AnnouncementVariableTimeLeft,
#[allow(missing_docs)] Chime,
#[allow(missing_docs)] Knock,
Unknown(String),
}
impl std::convert::From<&str> for EndOfMeetingReminderType {
fn from(s: &str) -> Self {
match s {
"ANNOUNCEMENT_TIME_CHECK" => EndOfMeetingReminderType::AnnouncementTimeCheck,
"ANNOUNCEMENT_VARIABLE_TIME_LEFT" => {
EndOfMeetingReminderType::AnnouncementVariableTimeLeft
}
"CHIME" => EndOfMeetingReminderType::Chime,
"KNOCK" => EndOfMeetingReminderType::Knock,
other => EndOfMeetingReminderType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for EndOfMeetingReminderType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(EndOfMeetingReminderType::from(s))
}
}
impl EndOfMeetingReminderType {
pub fn as_str(&self) -> &str {
match self {
EndOfMeetingReminderType::AnnouncementTimeCheck => "ANNOUNCEMENT_TIME_CHECK",
EndOfMeetingReminderType::AnnouncementVariableTimeLeft => {
"ANNOUNCEMENT_VARIABLE_TIME_LEFT"
}
EndOfMeetingReminderType::Chime => "CHIME",
EndOfMeetingReminderType::Knock => "KNOCK",
EndOfMeetingReminderType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&[
"ANNOUNCEMENT_TIME_CHECK",
"ANNOUNCEMENT_VARIABLE_TIME_LEFT",
"CHIME",
"KNOCK",
]
}
}
impl AsRef<str> for EndOfMeetingReminderType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum WakeWord {
#[allow(missing_docs)] Alexa,
#[allow(missing_docs)] Amazon,
#[allow(missing_docs)] Computer,
#[allow(missing_docs)] Echo,
Unknown(String),
}
impl std::convert::From<&str> for WakeWord {
fn from(s: &str) -> Self {
match s {
"ALEXA" => WakeWord::Alexa,
"AMAZON" => WakeWord::Amazon,
"COMPUTER" => WakeWord::Computer,
"ECHO" => WakeWord::Echo,
other => WakeWord::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for WakeWord {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(WakeWord::from(s))
}
}
impl WakeWord {
pub fn as_str(&self) -> &str {
match self {
WakeWord::Alexa => "ALEXA",
WakeWord::Amazon => "AMAZON",
WakeWord::Computer => "COMPUTER",
WakeWord::Echo => "ECHO",
WakeWord::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ALEXA", "AMAZON", "COMPUTER", "ECHO"]
}
}
impl AsRef<str> for WakeWord {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum TemperatureUnit {
#[allow(missing_docs)] Celsius,
#[allow(missing_docs)] Fahrenheit,
Unknown(String),
}
impl std::convert::From<&str> for TemperatureUnit {
fn from(s: &str) -> Self {
match s {
"CELSIUS" => TemperatureUnit::Celsius,
"FAHRENHEIT" => TemperatureUnit::Fahrenheit,
other => TemperatureUnit::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for TemperatureUnit {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(TemperatureUnit::from(s))
}
}
impl TemperatureUnit {
pub fn as_str(&self) -> &str {
match self {
TemperatureUnit::Celsius => "CELSIUS",
TemperatureUnit::Fahrenheit => "FAHRENHEIT",
TemperatureUnit::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["CELSIUS", "FAHRENHEIT"]
}
}
impl AsRef<str> for TemperatureUnit {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DistanceUnit {
#[allow(missing_docs)] Imperial,
#[allow(missing_docs)] Metric,
Unknown(String),
}
impl std::convert::From<&str> for DistanceUnit {
fn from(s: &str) -> Self {
match s {
"IMPERIAL" => DistanceUnit::Imperial,
"METRIC" => DistanceUnit::Metric,
other => DistanceUnit::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for DistanceUnit {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DistanceUnit::from(s))
}
}
impl DistanceUnit {
pub fn as_str(&self) -> &str {
match self {
DistanceUnit::Imperial => "IMPERIAL",
DistanceUnit::Metric => "METRIC",
DistanceUnit::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["IMPERIAL", "METRIC"]
}
}
impl AsRef<str> for DistanceUnit {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SipAddress {
pub uri: std::option::Option<std::string::String>,
pub r#type: std::option::Option<crate::model::SipType>,
}
impl SipAddress {
pub fn uri(&self) -> std::option::Option<&str> {
self.uri.as_deref()
}
pub fn r#type(&self) -> std::option::Option<&crate::model::SipType> {
self.r#type.as_ref()
}
}
impl std::fmt::Debug for SipAddress {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SipAddress");
formatter.field("uri", &"*** Sensitive Data Redacted ***");
formatter.field("r#type", &"*** Sensitive Data Redacted ***");
formatter.finish()
}
}
pub mod sip_address {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) uri: std::option::Option<std::string::String>,
pub(crate) r#type: std::option::Option<crate::model::SipType>,
}
impl Builder {
pub fn uri(mut self, input: impl Into<std::string::String>) -> Self {
self.uri = Some(input.into());
self
}
pub fn set_uri(mut self, input: std::option::Option<std::string::String>) -> Self {
self.uri = input;
self
}
pub fn r#type(mut self, input: crate::model::SipType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(mut self, input: std::option::Option<crate::model::SipType>) -> Self {
self.r#type = input;
self
}
pub fn build(self) -> crate::model::SipAddress {
crate::model::SipAddress {
uri: self.uri,
r#type: self.r#type,
}
}
}
}
impl SipAddress {
pub fn builder() -> crate::model::sip_address::Builder {
crate::model::sip_address::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum SipType {
#[allow(missing_docs)] Work,
Unknown(String),
}
impl std::convert::From<&str> for SipType {
fn from(s: &str) -> Self {
match s {
"WORK" => SipType::Work,
other => SipType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for SipType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SipType::from(s))
}
}
impl SipType {
pub fn as_str(&self) -> &str {
match self {
SipType::Work => "WORK",
SipType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["WORK"]
}
}
impl AsRef<str> for SipType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PhoneNumber {
pub number: std::option::Option<std::string::String>,
pub r#type: std::option::Option<crate::model::PhoneNumberType>,
}
impl PhoneNumber {
pub fn number(&self) -> std::option::Option<&str> {
self.number.as_deref()
}
pub fn r#type(&self) -> std::option::Option<&crate::model::PhoneNumberType> {
self.r#type.as_ref()
}
}
impl std::fmt::Debug for PhoneNumber {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("PhoneNumber");
formatter.field("number", &"*** Sensitive Data Redacted ***");
formatter.field("r#type", &"*** Sensitive Data Redacted ***");
formatter.finish()
}
}
pub mod phone_number {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) number: std::option::Option<std::string::String>,
pub(crate) r#type: std::option::Option<crate::model::PhoneNumberType>,
}
impl Builder {
pub fn number(mut self, input: impl Into<std::string::String>) -> Self {
self.number = Some(input.into());
self
}
pub fn set_number(mut self, input: std::option::Option<std::string::String>) -> Self {
self.number = input;
self
}
pub fn r#type(mut self, input: crate::model::PhoneNumberType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(
mut self,
input: std::option::Option<crate::model::PhoneNumberType>,
) -> Self {
self.r#type = input;
self
}
pub fn build(self) -> crate::model::PhoneNumber {
crate::model::PhoneNumber {
number: self.number,
r#type: self.r#type,
}
}
}
}
impl PhoneNumber {
pub fn builder() -> crate::model::phone_number::Builder {
crate::model::phone_number::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum PhoneNumberType {
#[allow(missing_docs)] Home,
#[allow(missing_docs)] Mobile,
#[allow(missing_docs)] Work,
Unknown(String),
}
impl std::convert::From<&str> for PhoneNumberType {
fn from(s: &str) -> Self {
match s {
"HOME" => PhoneNumberType::Home,
"MOBILE" => PhoneNumberType::Mobile,
"WORK" => PhoneNumberType::Work,
other => PhoneNumberType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for PhoneNumberType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(PhoneNumberType::from(s))
}
}
impl PhoneNumberType {
pub fn as_str(&self) -> &str {
match self {
PhoneNumberType::Home => "HOME",
PhoneNumberType::Mobile => "MOBILE",
PhoneNumberType::Work => "WORK",
PhoneNumberType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["HOME", "MOBILE", "WORK"]
}
}
impl AsRef<str> for PhoneNumberType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct MeetingSetting {
pub require_pin: std::option::Option<crate::model::RequirePin>,
}
impl MeetingSetting {
pub fn require_pin(&self) -> std::option::Option<&crate::model::RequirePin> {
self.require_pin.as_ref()
}
}
impl std::fmt::Debug for MeetingSetting {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("MeetingSetting");
formatter.field("require_pin", &self.require_pin);
formatter.finish()
}
}
pub mod meeting_setting {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) require_pin: std::option::Option<crate::model::RequirePin>,
}
impl Builder {
pub fn require_pin(mut self, input: crate::model::RequirePin) -> Self {
self.require_pin = Some(input);
self
}
pub fn set_require_pin(
mut self,
input: std::option::Option<crate::model::RequirePin>,
) -> Self {
self.require_pin = input;
self
}
pub fn build(self) -> crate::model::MeetingSetting {
crate::model::MeetingSetting {
require_pin: self.require_pin,
}
}
}
}
impl MeetingSetting {
pub fn builder() -> crate::model::meeting_setting::Builder {
crate::model::meeting_setting::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum RequirePin {
#[allow(missing_docs)] No,
#[allow(missing_docs)] Optional,
#[allow(missing_docs)] Yes,
Unknown(String),
}
impl std::convert::From<&str> for RequirePin {
fn from(s: &str) -> Self {
match s {
"NO" => RequirePin::No,
"OPTIONAL" => RequirePin::Optional,
"YES" => RequirePin::Yes,
other => RequirePin::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for RequirePin {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(RequirePin::from(s))
}
}
impl RequirePin {
pub fn as_str(&self) -> &str {
match self {
RequirePin::No => "NO",
RequirePin::Optional => "OPTIONAL",
RequirePin::Yes => "YES",
RequirePin::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["NO", "OPTIONAL", "YES"]
}
}
impl AsRef<str> for RequirePin {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PstnDialIn {
pub country_code: std::option::Option<std::string::String>,
pub phone_number: std::option::Option<std::string::String>,
pub one_click_id_delay: std::option::Option<std::string::String>,
pub one_click_pin_delay: std::option::Option<std::string::String>,
}
impl PstnDialIn {
pub fn country_code(&self) -> std::option::Option<&str> {
self.country_code.as_deref()
}
pub fn phone_number(&self) -> std::option::Option<&str> {
self.phone_number.as_deref()
}
pub fn one_click_id_delay(&self) -> std::option::Option<&str> {
self.one_click_id_delay.as_deref()
}
pub fn one_click_pin_delay(&self) -> std::option::Option<&str> {
self.one_click_pin_delay.as_deref()
}
}
impl std::fmt::Debug for PstnDialIn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("PstnDialIn");
formatter.field("country_code", &self.country_code);
formatter.field("phone_number", &self.phone_number);
formatter.field("one_click_id_delay", &self.one_click_id_delay);
formatter.field("one_click_pin_delay", &self.one_click_pin_delay);
formatter.finish()
}
}
pub mod pstn_dial_in {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) country_code: std::option::Option<std::string::String>,
pub(crate) phone_number: std::option::Option<std::string::String>,
pub(crate) one_click_id_delay: std::option::Option<std::string::String>,
pub(crate) one_click_pin_delay: std::option::Option<std::string::String>,
}
impl Builder {
pub fn country_code(mut self, input: impl Into<std::string::String>) -> Self {
self.country_code = Some(input.into());
self
}
pub fn set_country_code(mut self, input: std::option::Option<std::string::String>) -> Self {
self.country_code = input;
self
}
pub fn phone_number(mut self, input: impl Into<std::string::String>) -> Self {
self.phone_number = Some(input.into());
self
}
pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
self.phone_number = input;
self
}
pub fn one_click_id_delay(mut self, input: impl Into<std::string::String>) -> Self {
self.one_click_id_delay = Some(input.into());
self
}
pub fn set_one_click_id_delay(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.one_click_id_delay = input;
self
}
pub fn one_click_pin_delay(mut self, input: impl Into<std::string::String>) -> Self {
self.one_click_pin_delay = Some(input.into());
self
}
pub fn set_one_click_pin_delay(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.one_click_pin_delay = input;
self
}
pub fn build(self) -> crate::model::PstnDialIn {
crate::model::PstnDialIn {
country_code: self.country_code,
phone_number: self.phone_number,
one_click_id_delay: self.one_click_id_delay,
one_click_pin_delay: self.one_click_pin_delay,
}
}
}
}
impl PstnDialIn {
pub fn builder() -> crate::model::pstn_dial_in::Builder {
crate::model::pstn_dial_in::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct IpDialIn {
pub endpoint: std::option::Option<std::string::String>,
pub comms_protocol: std::option::Option<crate::model::CommsProtocol>,
}
impl IpDialIn {
pub fn endpoint(&self) -> std::option::Option<&str> {
self.endpoint.as_deref()
}
pub fn comms_protocol(&self) -> std::option::Option<&crate::model::CommsProtocol> {
self.comms_protocol.as_ref()
}
}
impl std::fmt::Debug for IpDialIn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("IpDialIn");
formatter.field("endpoint", &self.endpoint);
formatter.field("comms_protocol", &self.comms_protocol);
formatter.finish()
}
}
pub mod ip_dial_in {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint: std::option::Option<std::string::String>,
pub(crate) comms_protocol: std::option::Option<crate::model::CommsProtocol>,
}
impl Builder {
pub fn endpoint(mut self, input: impl Into<std::string::String>) -> Self {
self.endpoint = Some(input.into());
self
}
pub fn set_endpoint(mut self, input: std::option::Option<std::string::String>) -> Self {
self.endpoint = input;
self
}
pub fn comms_protocol(mut self, input: crate::model::CommsProtocol) -> Self {
self.comms_protocol = Some(input);
self
}
pub fn set_comms_protocol(
mut self,
input: std::option::Option<crate::model::CommsProtocol>,
) -> Self {
self.comms_protocol = input;
self
}
pub fn build(self) -> crate::model::IpDialIn {
crate::model::IpDialIn {
endpoint: self.endpoint,
comms_protocol: self.comms_protocol,
}
}
}
}
impl IpDialIn {
pub fn builder() -> crate::model::ip_dial_in::Builder {
crate::model::ip_dial_in::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum CommsProtocol {
#[allow(missing_docs)] H323,
#[allow(missing_docs)] Sip,
#[allow(missing_docs)] Sips,
Unknown(String),
}
impl std::convert::From<&str> for CommsProtocol {
fn from(s: &str) -> Self {
match s {
"H323" => CommsProtocol::H323,
"SIP" => CommsProtocol::Sip,
"SIPS" => CommsProtocol::Sips,
other => CommsProtocol::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for CommsProtocol {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(CommsProtocol::from(s))
}
}
impl CommsProtocol {
pub fn as_str(&self) -> &str {
match self {
CommsProtocol::H323 => "H323",
CommsProtocol::Sip => "SIP",
CommsProtocol::Sips => "SIPS",
CommsProtocol::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["H323", "SIP", "SIPS"]
}
}
impl AsRef<str> for CommsProtocol {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum ConferenceProviderType {
#[allow(missing_docs)] Bluejeans,
#[allow(missing_docs)] Chime,
#[allow(missing_docs)] Custom,
#[allow(missing_docs)] Fuze,
#[allow(missing_docs)] GoogleHangouts,
#[allow(missing_docs)] Polycom,
#[allow(missing_docs)] Ringcentral,
#[allow(missing_docs)] SkypeForBusiness,
#[allow(missing_docs)] Webex,
#[allow(missing_docs)] Zoom,
Unknown(String),
}
impl std::convert::From<&str> for ConferenceProviderType {
fn from(s: &str) -> Self {
match s {
"BLUEJEANS" => ConferenceProviderType::Bluejeans,
"CHIME" => ConferenceProviderType::Chime,
"CUSTOM" => ConferenceProviderType::Custom,
"FUZE" => ConferenceProviderType::Fuze,
"GOOGLE_HANGOUTS" => ConferenceProviderType::GoogleHangouts,
"POLYCOM" => ConferenceProviderType::Polycom,
"RINGCENTRAL" => ConferenceProviderType::Ringcentral,
"SKYPE_FOR_BUSINESS" => ConferenceProviderType::SkypeForBusiness,
"WEBEX" => ConferenceProviderType::Webex,
"ZOOM" => ConferenceProviderType::Zoom,
other => ConferenceProviderType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for ConferenceProviderType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ConferenceProviderType::from(s))
}
}
impl ConferenceProviderType {
pub fn as_str(&self) -> &str {
match self {
ConferenceProviderType::Bluejeans => "BLUEJEANS",
ConferenceProviderType::Chime => "CHIME",
ConferenceProviderType::Custom => "CUSTOM",
ConferenceProviderType::Fuze => "FUZE",
ConferenceProviderType::GoogleHangouts => "GOOGLE_HANGOUTS",
ConferenceProviderType::Polycom => "POLYCOM",
ConferenceProviderType::Ringcentral => "RINGCENTRAL",
ConferenceProviderType::SkypeForBusiness => "SKYPE_FOR_BUSINESS",
ConferenceProviderType::Webex => "WEBEX",
ConferenceProviderType::Zoom => "ZOOM",
ConferenceProviderType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&[
"BLUEJEANS",
"CHIME",
"CUSTOM",
"FUZE",
"GOOGLE_HANGOUTS",
"POLYCOM",
"RINGCENTRAL",
"SKYPE_FOR_BUSINESS",
"WEBEX",
"ZOOM",
]
}
}
impl AsRef<str> for ConferenceProviderType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BusinessReportRecurrence {
pub start_date: std::option::Option<std::string::String>,
}
impl BusinessReportRecurrence {
pub fn start_date(&self) -> std::option::Option<&str> {
self.start_date.as_deref()
}
}
impl std::fmt::Debug for BusinessReportRecurrence {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("BusinessReportRecurrence");
formatter.field("start_date", &self.start_date);
formatter.finish()
}
}
pub mod business_report_recurrence {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) start_date: std::option::Option<std::string::String>,
}
impl Builder {
pub fn start_date(mut self, input: impl Into<std::string::String>) -> Self {
self.start_date = Some(input.into());
self
}
pub fn set_start_date(mut self, input: std::option::Option<std::string::String>) -> Self {
self.start_date = input;
self
}
pub fn build(self) -> crate::model::BusinessReportRecurrence {
crate::model::BusinessReportRecurrence {
start_date: self.start_date,
}
}
}
}
impl BusinessReportRecurrence {
pub fn builder() -> crate::model::business_report_recurrence::Builder {
crate::model::business_report_recurrence::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum BusinessReportFormat {
#[allow(missing_docs)] Csv,
#[allow(missing_docs)] CsvZip,
Unknown(String),
}
impl std::convert::From<&str> for BusinessReportFormat {
fn from(s: &str) -> Self {
match s {
"CSV" => BusinessReportFormat::Csv,
"CSV_ZIP" => BusinessReportFormat::CsvZip,
other => BusinessReportFormat::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for BusinessReportFormat {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(BusinessReportFormat::from(s))
}
}
impl BusinessReportFormat {
pub fn as_str(&self) -> &str {
match self {
BusinessReportFormat::Csv => "CSV",
BusinessReportFormat::CsvZip => "CSV_ZIP",
BusinessReportFormat::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["CSV", "CSV_ZIP"]
}
}
impl AsRef<str> for BusinessReportFormat {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Tag {
pub key: std::option::Option<std::string::String>,
pub value: std::option::Option<std::string::String>,
}
impl Tag {
pub fn key(&self) -> std::option::Option<&str> {
self.key.as_deref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
}
impl std::fmt::Debug for Tag {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Tag");
formatter.field("key", &self.key);
formatter.field("value", &self.value);
formatter.finish()
}
}
pub mod tag {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) key: std::option::Option<std::string::String>,
pub(crate) value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn key(mut self, input: impl Into<std::string::String>) -> Self {
self.key = Some(input.into());
self
}
pub fn set_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.key = input;
self
}
pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
self.value = Some(input.into());
self
}
pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
self.value = input;
self
}
pub fn build(self) -> crate::model::Tag {
crate::model::Tag {
key: self.key,
value: self.value,
}
}
}
}
impl Tag {
pub fn builder() -> crate::model::tag::Builder {
crate::model::tag::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum Feature {
#[allow(missing_docs)] All,
#[allow(missing_docs)] Bluetooth,
#[allow(missing_docs)] Lists,
#[allow(missing_docs)] NetworkProfile,
#[allow(missing_docs)] Notifications,
#[allow(missing_docs)] Settings,
#[allow(missing_docs)] Skills,
#[allow(missing_docs)] Volume,
Unknown(String),
}
impl std::convert::From<&str> for Feature {
fn from(s: &str) -> Self {
match s {
"ALL" => Feature::All,
"BLUETOOTH" => Feature::Bluetooth,
"LISTS" => Feature::Lists,
"NETWORK_PROFILE" => Feature::NetworkProfile,
"NOTIFICATIONS" => Feature::Notifications,
"SETTINGS" => Feature::Settings,
"SKILLS" => Feature::Skills,
"VOLUME" => Feature::Volume,
other => Feature::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for Feature {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(Feature::from(s))
}
}
impl Feature {
pub fn as_str(&self) -> &str {
match self {
Feature::All => "ALL",
Feature::Bluetooth => "BLUETOOTH",
Feature::Lists => "LISTS",
Feature::NetworkProfile => "NETWORK_PROFILE",
Feature::Notifications => "NOTIFICATIONS",
Feature::Settings => "SETTINGS",
Feature::Skills => "SKILLS",
Feature::Volume => "VOLUME",
Feature::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&[
"ALL",
"BLUETOOTH",
"LISTS",
"NETWORK_PROFILE",
"NOTIFICATIONS",
"SETTINGS",
"SKILLS",
"VOLUME",
]
}
}
impl AsRef<str> for Feature {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Content {
pub text_list: std::option::Option<std::vec::Vec<crate::model::Text>>,
pub ssml_list: std::option::Option<std::vec::Vec<crate::model::Ssml>>,
pub audio_list: std::option::Option<std::vec::Vec<crate::model::Audio>>,
}
impl Content {
pub fn text_list(&self) -> std::option::Option<&[crate::model::Text]> {
self.text_list.as_deref()
}
pub fn ssml_list(&self) -> std::option::Option<&[crate::model::Ssml]> {
self.ssml_list.as_deref()
}
pub fn audio_list(&self) -> std::option::Option<&[crate::model::Audio]> {
self.audio_list.as_deref()
}
}
impl std::fmt::Debug for Content {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Content");
formatter.field("text_list", &self.text_list);
formatter.field("ssml_list", &self.ssml_list);
formatter.field("audio_list", &self.audio_list);
formatter.finish()
}
}
pub mod content {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) text_list: std::option::Option<std::vec::Vec<crate::model::Text>>,
pub(crate) ssml_list: std::option::Option<std::vec::Vec<crate::model::Ssml>>,
pub(crate) audio_list: std::option::Option<std::vec::Vec<crate::model::Audio>>,
}
impl Builder {
pub fn text_list(mut self, input: impl Into<crate::model::Text>) -> Self {
let mut v = self.text_list.unwrap_or_default();
v.push(input.into());
self.text_list = Some(v);
self
}
pub fn set_text_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Text>>,
) -> Self {
self.text_list = input;
self
}
pub fn ssml_list(mut self, input: impl Into<crate::model::Ssml>) -> Self {
let mut v = self.ssml_list.unwrap_or_default();
v.push(input.into());
self.ssml_list = Some(v);
self
}
pub fn set_ssml_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Ssml>>,
) -> Self {
self.ssml_list = input;
self
}
pub fn audio_list(mut self, input: impl Into<crate::model::Audio>) -> Self {
let mut v = self.audio_list.unwrap_or_default();
v.push(input.into());
self.audio_list = Some(v);
self
}
pub fn set_audio_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Audio>>,
) -> Self {
self.audio_list = input;
self
}
pub fn build(self) -> crate::model::Content {
crate::model::Content {
text_list: self.text_list,
ssml_list: self.ssml_list,
audio_list: self.audio_list,
}
}
}
}
impl Content {
pub fn builder() -> crate::model::content::Builder {
crate::model::content::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Audio {
pub locale: std::option::Option<crate::model::Locale>,
pub location: std::option::Option<std::string::String>,
}
impl Audio {
pub fn locale(&self) -> std::option::Option<&crate::model::Locale> {
self.locale.as_ref()
}
pub fn location(&self) -> std::option::Option<&str> {
self.location.as_deref()
}
}
impl std::fmt::Debug for Audio {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Audio");
formatter.field("locale", &self.locale);
formatter.field("location", &self.location);
formatter.finish()
}
}
pub mod audio {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) locale: std::option::Option<crate::model::Locale>,
pub(crate) location: std::option::Option<std::string::String>,
}
impl Builder {
pub fn locale(mut self, input: crate::model::Locale) -> Self {
self.locale = Some(input);
self
}
pub fn set_locale(mut self, input: std::option::Option<crate::model::Locale>) -> Self {
self.locale = input;
self
}
pub fn location(mut self, input: impl Into<std::string::String>) -> Self {
self.location = Some(input.into());
self
}
pub fn set_location(mut self, input: std::option::Option<std::string::String>) -> Self {
self.location = input;
self
}
pub fn build(self) -> crate::model::Audio {
crate::model::Audio {
locale: self.locale,
location: self.location,
}
}
}
}
impl Audio {
pub fn builder() -> crate::model::audio::Builder {
crate::model::audio::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum Locale {
#[allow(missing_docs)] EnUs,
Unknown(String),
}
impl std::convert::From<&str> for Locale {
fn from(s: &str) -> Self {
match s {
"en-US" => Locale::EnUs,
other => Locale::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for Locale {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(Locale::from(s))
}
}
impl Locale {
pub fn as_str(&self) -> &str {
match self {
Locale::EnUs => "en-US",
Locale::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["en-US"]
}
}
impl AsRef<str> for Locale {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Ssml {
pub locale: std::option::Option<crate::model::Locale>,
pub value: std::option::Option<std::string::String>,
}
impl Ssml {
pub fn locale(&self) -> std::option::Option<&crate::model::Locale> {
self.locale.as_ref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
}
impl std::fmt::Debug for Ssml {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Ssml");
formatter.field("locale", &self.locale);
formatter.field("value", &self.value);
formatter.finish()
}
}
pub mod ssml {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) locale: std::option::Option<crate::model::Locale>,
pub(crate) value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn locale(mut self, input: crate::model::Locale) -> Self {
self.locale = Some(input);
self
}
pub fn set_locale(mut self, input: std::option::Option<crate::model::Locale>) -> Self {
self.locale = input;
self
}
pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
self.value = Some(input.into());
self
}
pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
self.value = input;
self
}
pub fn build(self) -> crate::model::Ssml {
crate::model::Ssml {
locale: self.locale,
value: self.value,
}
}
}
}
impl Ssml {
pub fn builder() -> crate::model::ssml::Builder {
crate::model::ssml::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Text {
pub locale: std::option::Option<crate::model::Locale>,
pub value: std::option::Option<std::string::String>,
}
impl Text {
pub fn locale(&self) -> std::option::Option<&crate::model::Locale> {
self.locale.as_ref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
}
impl std::fmt::Debug for Text {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Text");
formatter.field("locale", &self.locale);
formatter.field("value", &self.value);
formatter.finish()
}
}
pub mod text {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) locale: std::option::Option<crate::model::Locale>,
pub(crate) value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn locale(mut self, input: crate::model::Locale) -> Self {
self.locale = Some(input);
self
}
pub fn set_locale(mut self, input: std::option::Option<crate::model::Locale>) -> Self {
self.locale = input;
self
}
pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
self.value = Some(input.into());
self
}
pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
self.value = input;
self
}
pub fn build(self) -> crate::model::Text {
crate::model::Text {
locale: self.locale,
value: self.value,
}
}
}
}
impl Text {
pub fn builder() -> crate::model::text::Builder {
crate::model::text::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Filter {
pub key: std::option::Option<std::string::String>,
pub values: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Filter {
pub fn key(&self) -> std::option::Option<&str> {
self.key.as_deref()
}
pub fn values(&self) -> std::option::Option<&[std::string::String]> {
self.values.as_deref()
}
}
impl std::fmt::Debug for Filter {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Filter");
formatter.field("key", &self.key);
formatter.field("values", &self.values);
formatter.finish()
}
}
pub mod filter {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) key: std::option::Option<std::string::String>,
pub(crate) values: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn key(mut self, input: impl Into<std::string::String>) -> Self {
self.key = Some(input.into());
self
}
pub fn set_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.key = input;
self
}
pub fn values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.values.unwrap_or_default();
v.push(input.into());
self.values = Some(v);
self
}
pub fn set_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.values = input;
self
}
pub fn build(self) -> crate::model::Filter {
crate::model::Filter {
key: self.key,
values: self.values,
}
}
}
}
impl Filter {
pub fn builder() -> crate::model::filter::Builder {
crate::model::filter::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UserData {
pub user_arn: std::option::Option<std::string::String>,
pub first_name: std::option::Option<std::string::String>,
pub last_name: std::option::Option<std::string::String>,
pub email: std::option::Option<std::string::String>,
pub enrollment_status: std::option::Option<crate::model::EnrollmentStatus>,
pub enrollment_id: std::option::Option<std::string::String>,
}
impl UserData {
pub fn user_arn(&self) -> std::option::Option<&str> {
self.user_arn.as_deref()
}
pub fn first_name(&self) -> std::option::Option<&str> {
self.first_name.as_deref()
}
pub fn last_name(&self) -> std::option::Option<&str> {
self.last_name.as_deref()
}
pub fn email(&self) -> std::option::Option<&str> {
self.email.as_deref()
}
pub fn enrollment_status(&self) -> std::option::Option<&crate::model::EnrollmentStatus> {
self.enrollment_status.as_ref()
}
pub fn enrollment_id(&self) -> std::option::Option<&str> {
self.enrollment_id.as_deref()
}
}
impl std::fmt::Debug for UserData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UserData");
formatter.field("user_arn", &self.user_arn);
formatter.field("first_name", &self.first_name);
formatter.field("last_name", &self.last_name);
formatter.field("email", &self.email);
formatter.field("enrollment_status", &self.enrollment_status);
formatter.field("enrollment_id", &self.enrollment_id);
formatter.finish()
}
}
pub mod user_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_arn: std::option::Option<std::string::String>,
pub(crate) first_name: std::option::Option<std::string::String>,
pub(crate) last_name: std::option::Option<std::string::String>,
pub(crate) email: std::option::Option<std::string::String>,
pub(crate) enrollment_status: std::option::Option<crate::model::EnrollmentStatus>,
pub(crate) enrollment_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.user_arn = Some(input.into());
self
}
pub fn set_user_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_arn = input;
self
}
pub fn first_name(mut self, input: impl Into<std::string::String>) -> Self {
self.first_name = Some(input.into());
self
}
pub fn set_first_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.first_name = input;
self
}
pub fn last_name(mut self, input: impl Into<std::string::String>) -> Self {
self.last_name = Some(input.into());
self
}
pub fn set_last_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.last_name = input;
self
}
pub fn email(mut self, input: impl Into<std::string::String>) -> Self {
self.email = Some(input.into());
self
}
pub fn set_email(mut self, input: std::option::Option<std::string::String>) -> Self {
self.email = input;
self
}
pub fn enrollment_status(mut self, input: crate::model::EnrollmentStatus) -> Self {
self.enrollment_status = Some(input);
self
}
pub fn set_enrollment_status(
mut self,
input: std::option::Option<crate::model::EnrollmentStatus>,
) -> Self {
self.enrollment_status = input;
self
}
pub fn enrollment_id(mut self, input: impl Into<std::string::String>) -> Self {
self.enrollment_id = Some(input.into());
self
}
pub fn set_enrollment_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.enrollment_id = input;
self
}
pub fn build(self) -> crate::model::UserData {
crate::model::UserData {
user_arn: self.user_arn,
first_name: self.first_name,
last_name: self.last_name,
email: self.email,
enrollment_status: self.enrollment_status,
enrollment_id: self.enrollment_id,
}
}
}
}
impl UserData {
pub fn builder() -> crate::model::user_data::Builder {
crate::model::user_data::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum EnrollmentStatus {
#[allow(missing_docs)] Deregistering,
#[allow(missing_docs)] Disassociating,
#[allow(missing_docs)] Initialized,
#[allow(missing_docs)] Pending,
#[allow(missing_docs)] Registered,
Unknown(String),
}
impl std::convert::From<&str> for EnrollmentStatus {
fn from(s: &str) -> Self {
match s {
"DEREGISTERING" => EnrollmentStatus::Deregistering,
"DISASSOCIATING" => EnrollmentStatus::Disassociating,
"INITIALIZED" => EnrollmentStatus::Initialized,
"PENDING" => EnrollmentStatus::Pending,
"REGISTERED" => EnrollmentStatus::Registered,
other => EnrollmentStatus::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for EnrollmentStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(EnrollmentStatus::from(s))
}
}
impl EnrollmentStatus {
pub fn as_str(&self) -> &str {
match self {
EnrollmentStatus::Deregistering => "DEREGISTERING",
EnrollmentStatus::Disassociating => "DISASSOCIATING",
EnrollmentStatus::Initialized => "INITIALIZED",
EnrollmentStatus::Pending => "PENDING",
EnrollmentStatus::Registered => "REGISTERED",
EnrollmentStatus::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&[
"DEREGISTERING",
"DISASSOCIATING",
"INITIALIZED",
"PENDING",
"REGISTERED",
]
}
}
impl AsRef<str> for EnrollmentStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Sort {
pub key: std::option::Option<std::string::String>,
pub value: std::option::Option<crate::model::SortValue>,
}
impl Sort {
pub fn key(&self) -> std::option::Option<&str> {
self.key.as_deref()
}
pub fn value(&self) -> std::option::Option<&crate::model::SortValue> {
self.value.as_ref()
}
}
impl std::fmt::Debug for Sort {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Sort");
formatter.field("key", &self.key);
formatter.field("value", &self.value);
formatter.finish()
}
}
pub mod sort {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) key: std::option::Option<std::string::String>,
pub(crate) value: std::option::Option<crate::model::SortValue>,
}
impl Builder {
pub fn key(mut self, input: impl Into<std::string::String>) -> Self {
self.key = Some(input.into());
self
}
pub fn set_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.key = input;
self
}
pub fn value(mut self, input: crate::model::SortValue) -> Self {
self.value = Some(input);
self
}
pub fn set_value(mut self, input: std::option::Option<crate::model::SortValue>) -> Self {
self.value = input;
self
}
pub fn build(self) -> crate::model::Sort {
crate::model::Sort {
key: self.key,
value: self.value,
}
}
}
}
impl Sort {
pub fn builder() -> crate::model::sort::Builder {
crate::model::sort::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum SortValue {
#[allow(missing_docs)] Asc,
#[allow(missing_docs)] Desc,
Unknown(String),
}
impl std::convert::From<&str> for SortValue {
fn from(s: &str) -> Self {
match s {
"ASC" => SortValue::Asc,
"DESC" => SortValue::Desc,
other => SortValue::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for SortValue {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SortValue::from(s))
}
}
impl SortValue {
pub fn as_str(&self) -> &str {
match self {
SortValue::Asc => "ASC",
SortValue::Desc => "DESC",
SortValue::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ASC", "DESC"]
}
}
impl AsRef<str> for SortValue {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SkillGroupData {
pub skill_group_arn: std::option::Option<std::string::String>,
pub skill_group_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl SkillGroupData {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn skill_group_name(&self) -> std::option::Option<&str> {
self.skill_group_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for SkillGroupData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SkillGroupData");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("skill_group_name", &self.skill_group_name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod skill_group_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) skill_group_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn skill_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_name = Some(input.into());
self
}
pub fn set_skill_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::SkillGroupData {
crate::model::SkillGroupData {
skill_group_arn: self.skill_group_arn,
skill_group_name: self.skill_group_name,
description: self.description,
}
}
}
}
impl SkillGroupData {
pub fn builder() -> crate::model::skill_group_data::Builder {
crate::model::skill_group_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RoomData {
pub room_arn: std::option::Option<std::string::String>,
pub room_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub provider_calendar_id: std::option::Option<std::string::String>,
pub profile_arn: std::option::Option<std::string::String>,
pub profile_name: std::option::Option<std::string::String>,
}
impl RoomData {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn room_name(&self) -> std::option::Option<&str> {
self.room_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn provider_calendar_id(&self) -> std::option::Option<&str> {
self.provider_calendar_id.as_deref()
}
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
pub fn profile_name(&self) -> std::option::Option<&str> {
self.profile_name.as_deref()
}
}
impl std::fmt::Debug for RoomData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RoomData");
formatter.field("room_arn", &self.room_arn);
formatter.field("room_name", &self.room_name);
formatter.field("description", &self.description);
formatter.field("provider_calendar_id", &self.provider_calendar_id);
formatter.field("profile_arn", &self.profile_arn);
formatter.field("profile_name", &self.profile_name);
formatter.finish()
}
}
pub mod room_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) room_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) provider_calendar_id: std::option::Option<std::string::String>,
pub(crate) profile_arn: std::option::Option<std::string::String>,
pub(crate) profile_name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn room_name(mut self, input: impl Into<std::string::String>) -> Self {
self.room_name = Some(input.into());
self
}
pub fn set_room_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn provider_calendar_id(mut self, input: impl Into<std::string::String>) -> Self {
self.provider_calendar_id = Some(input.into());
self
}
pub fn set_provider_calendar_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.provider_calendar_id = input;
self
}
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_name = Some(input.into());
self
}
pub fn set_profile_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_name = input;
self
}
pub fn build(self) -> crate::model::RoomData {
crate::model::RoomData {
room_arn: self.room_arn,
room_name: self.room_name,
description: self.description,
provider_calendar_id: self.provider_calendar_id,
profile_arn: self.profile_arn,
profile_name: self.profile_name,
}
}
}
}
impl RoomData {
pub fn builder() -> crate::model::room_data::Builder {
crate::model::room_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ProfileData {
pub profile_arn: std::option::Option<std::string::String>,
pub profile_name: std::option::Option<std::string::String>,
pub is_default: std::option::Option<bool>,
pub address: std::option::Option<std::string::String>,
pub timezone: std::option::Option<std::string::String>,
pub distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub wake_word: std::option::Option<crate::model::WakeWord>,
pub locale: std::option::Option<std::string::String>,
}
impl ProfileData {
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
pub fn profile_name(&self) -> std::option::Option<&str> {
self.profile_name.as_deref()
}
pub fn is_default(&self) -> std::option::Option<bool> {
self.is_default
}
pub fn address(&self) -> std::option::Option<&str> {
self.address.as_deref()
}
pub fn timezone(&self) -> std::option::Option<&str> {
self.timezone.as_deref()
}
pub fn distance_unit(&self) -> std::option::Option<&crate::model::DistanceUnit> {
self.distance_unit.as_ref()
}
pub fn temperature_unit(&self) -> std::option::Option<&crate::model::TemperatureUnit> {
self.temperature_unit.as_ref()
}
pub fn wake_word(&self) -> std::option::Option<&crate::model::WakeWord> {
self.wake_word.as_ref()
}
pub fn locale(&self) -> std::option::Option<&str> {
self.locale.as_deref()
}
}
impl std::fmt::Debug for ProfileData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ProfileData");
formatter.field("profile_arn", &self.profile_arn);
formatter.field("profile_name", &self.profile_name);
formatter.field("is_default", &self.is_default);
formatter.field("address", &self.address);
formatter.field("timezone", &self.timezone);
formatter.field("distance_unit", &self.distance_unit);
formatter.field("temperature_unit", &self.temperature_unit);
formatter.field("wake_word", &self.wake_word);
formatter.field("locale", &self.locale);
formatter.finish()
}
}
pub mod profile_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_arn: std::option::Option<std::string::String>,
pub(crate) profile_name: std::option::Option<std::string::String>,
pub(crate) is_default: std::option::Option<bool>,
pub(crate) address: std::option::Option<std::string::String>,
pub(crate) timezone: std::option::Option<std::string::String>,
pub(crate) distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub(crate) temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub(crate) wake_word: std::option::Option<crate::model::WakeWord>,
pub(crate) locale: std::option::Option<std::string::String>,
}
impl Builder {
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_name = Some(input.into());
self
}
pub fn set_profile_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_name = input;
self
}
pub fn is_default(mut self, input: bool) -> Self {
self.is_default = Some(input);
self
}
pub fn set_is_default(mut self, input: std::option::Option<bool>) -> Self {
self.is_default = input;
self
}
pub fn address(mut self, input: impl Into<std::string::String>) -> Self {
self.address = Some(input.into());
self
}
pub fn set_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.address = input;
self
}
pub fn timezone(mut self, input: impl Into<std::string::String>) -> Self {
self.timezone = Some(input.into());
self
}
pub fn set_timezone(mut self, input: std::option::Option<std::string::String>) -> Self {
self.timezone = input;
self
}
pub fn distance_unit(mut self, input: crate::model::DistanceUnit) -> Self {
self.distance_unit = Some(input);
self
}
pub fn set_distance_unit(
mut self,
input: std::option::Option<crate::model::DistanceUnit>,
) -> Self {
self.distance_unit = input;
self
}
pub fn temperature_unit(mut self, input: crate::model::TemperatureUnit) -> Self {
self.temperature_unit = Some(input);
self
}
pub fn set_temperature_unit(
mut self,
input: std::option::Option<crate::model::TemperatureUnit>,
) -> Self {
self.temperature_unit = input;
self
}
pub fn wake_word(mut self, input: crate::model::WakeWord) -> Self {
self.wake_word = Some(input);
self
}
pub fn set_wake_word(mut self, input: std::option::Option<crate::model::WakeWord>) -> Self {
self.wake_word = input;
self
}
pub fn locale(mut self, input: impl Into<std::string::String>) -> Self {
self.locale = Some(input.into());
self
}
pub fn set_locale(mut self, input: std::option::Option<std::string::String>) -> Self {
self.locale = input;
self
}
pub fn build(self) -> crate::model::ProfileData {
crate::model::ProfileData {
profile_arn: self.profile_arn,
profile_name: self.profile_name,
is_default: self.is_default,
address: self.address,
timezone: self.timezone,
distance_unit: self.distance_unit,
temperature_unit: self.temperature_unit,
wake_word: self.wake_word,
locale: self.locale,
}
}
}
}
impl ProfileData {
pub fn builder() -> crate::model::profile_data::Builder {
crate::model::profile_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct NetworkProfileData {
pub network_profile_arn: std::option::Option<std::string::String>,
pub network_profile_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub ssid: std::option::Option<std::string::String>,
pub security_type: std::option::Option<crate::model::NetworkSecurityType>,
pub eap_method: std::option::Option<crate::model::NetworkEapMethod>,
pub certificate_authority_arn: std::option::Option<std::string::String>,
}
impl NetworkProfileData {
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
pub fn network_profile_name(&self) -> std::option::Option<&str> {
self.network_profile_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn ssid(&self) -> std::option::Option<&str> {
self.ssid.as_deref()
}
pub fn security_type(&self) -> std::option::Option<&crate::model::NetworkSecurityType> {
self.security_type.as_ref()
}
pub fn eap_method(&self) -> std::option::Option<&crate::model::NetworkEapMethod> {
self.eap_method.as_ref()
}
pub fn certificate_authority_arn(&self) -> std::option::Option<&str> {
self.certificate_authority_arn.as_deref()
}
}
impl std::fmt::Debug for NetworkProfileData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("NetworkProfileData");
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.field("network_profile_name", &self.network_profile_name);
formatter.field("description", &self.description);
formatter.field("ssid", &self.ssid);
formatter.field("security_type", &self.security_type);
formatter.field("eap_method", &self.eap_method);
formatter.field("certificate_authority_arn", &self.certificate_authority_arn);
formatter.finish()
}
}
pub mod network_profile_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
pub(crate) network_profile_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) ssid: std::option::Option<std::string::String>,
pub(crate) security_type: std::option::Option<crate::model::NetworkSecurityType>,
pub(crate) eap_method: std::option::Option<crate::model::NetworkEapMethod>,
pub(crate) certificate_authority_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn network_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_name = Some(input.into());
self
}
pub fn set_network_profile_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn ssid(mut self, input: impl Into<std::string::String>) -> Self {
self.ssid = Some(input.into());
self
}
pub fn set_ssid(mut self, input: std::option::Option<std::string::String>) -> Self {
self.ssid = input;
self
}
pub fn security_type(mut self, input: crate::model::NetworkSecurityType) -> Self {
self.security_type = Some(input);
self
}
pub fn set_security_type(
mut self,
input: std::option::Option<crate::model::NetworkSecurityType>,
) -> Self {
self.security_type = input;
self
}
pub fn eap_method(mut self, input: crate::model::NetworkEapMethod) -> Self {
self.eap_method = Some(input);
self
}
pub fn set_eap_method(
mut self,
input: std::option::Option<crate::model::NetworkEapMethod>,
) -> Self {
self.eap_method = input;
self
}
pub fn certificate_authority_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_authority_arn = Some(input.into());
self
}
pub fn set_certificate_authority_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_authority_arn = input;
self
}
pub fn build(self) -> crate::model::NetworkProfileData {
crate::model::NetworkProfileData {
network_profile_arn: self.network_profile_arn,
network_profile_name: self.network_profile_name,
description: self.description,
ssid: self.ssid,
security_type: self.security_type,
eap_method: self.eap_method,
certificate_authority_arn: self.certificate_authority_arn,
}
}
}
}
impl NetworkProfileData {
pub fn builder() -> crate::model::network_profile_data::Builder {
crate::model::network_profile_data::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum NetworkEapMethod {
#[allow(missing_docs)] EapTls,
Unknown(String),
}
impl std::convert::From<&str> for NetworkEapMethod {
fn from(s: &str) -> Self {
match s {
"EAP_TLS" => NetworkEapMethod::EapTls,
other => NetworkEapMethod::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for NetworkEapMethod {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(NetworkEapMethod::from(s))
}
}
impl NetworkEapMethod {
pub fn as_str(&self) -> &str {
match self {
NetworkEapMethod::EapTls => "EAP_TLS",
NetworkEapMethod::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["EAP_TLS"]
}
}
impl AsRef<str> for NetworkEapMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum NetworkSecurityType {
#[allow(missing_docs)] Open,
#[allow(missing_docs)] Wep,
#[allow(missing_docs)] Wpa2Enterprise,
#[allow(missing_docs)] Wpa2Psk,
#[allow(missing_docs)] WpaPsk,
Unknown(String),
}
impl std::convert::From<&str> for NetworkSecurityType {
fn from(s: &str) -> Self {
match s {
"OPEN" => NetworkSecurityType::Open,
"WEP" => NetworkSecurityType::Wep,
"WPA2_ENTERPRISE" => NetworkSecurityType::Wpa2Enterprise,
"WPA2_PSK" => NetworkSecurityType::Wpa2Psk,
"WPA_PSK" => NetworkSecurityType::WpaPsk,
other => NetworkSecurityType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for NetworkSecurityType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(NetworkSecurityType::from(s))
}
}
impl NetworkSecurityType {
pub fn as_str(&self) -> &str {
match self {
NetworkSecurityType::Open => "OPEN",
NetworkSecurityType::Wep => "WEP",
NetworkSecurityType::Wpa2Enterprise => "WPA2_ENTERPRISE",
NetworkSecurityType::Wpa2Psk => "WPA2_PSK",
NetworkSecurityType::WpaPsk => "WPA_PSK",
NetworkSecurityType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["OPEN", "WEP", "WPA2_ENTERPRISE", "WPA2_PSK", "WPA_PSK"]
}
}
impl AsRef<str> for NetworkSecurityType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeviceData {
pub device_arn: std::option::Option<std::string::String>,
pub device_serial_number: std::option::Option<std::string::String>,
pub device_type: std::option::Option<std::string::String>,
pub device_name: std::option::Option<std::string::String>,
pub software_version: std::option::Option<std::string::String>,
pub mac_address: std::option::Option<std::string::String>,
pub device_status: std::option::Option<crate::model::DeviceStatus>,
pub network_profile_arn: std::option::Option<std::string::String>,
pub network_profile_name: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
pub room_name: std::option::Option<std::string::String>,
pub device_status_info: std::option::Option<crate::model::DeviceStatusInfo>,
pub created_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl DeviceData {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn device_serial_number(&self) -> std::option::Option<&str> {
self.device_serial_number.as_deref()
}
pub fn device_type(&self) -> std::option::Option<&str> {
self.device_type.as_deref()
}
pub fn device_name(&self) -> std::option::Option<&str> {
self.device_name.as_deref()
}
pub fn software_version(&self) -> std::option::Option<&str> {
self.software_version.as_deref()
}
pub fn mac_address(&self) -> std::option::Option<&str> {
self.mac_address.as_deref()
}
pub fn device_status(&self) -> std::option::Option<&crate::model::DeviceStatus> {
self.device_status.as_ref()
}
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
pub fn network_profile_name(&self) -> std::option::Option<&str> {
self.network_profile_name.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn room_name(&self) -> std::option::Option<&str> {
self.room_name.as_deref()
}
pub fn device_status_info(&self) -> std::option::Option<&crate::model::DeviceStatusInfo> {
self.device_status_info.as_ref()
}
pub fn created_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.created_time.as_ref()
}
}
impl std::fmt::Debug for DeviceData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeviceData");
formatter.field("device_arn", &self.device_arn);
formatter.field("device_serial_number", &self.device_serial_number);
formatter.field("device_type", &self.device_type);
formatter.field("device_name", &self.device_name);
formatter.field("software_version", &self.software_version);
formatter.field("mac_address", &self.mac_address);
formatter.field("device_status", &self.device_status);
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.field("network_profile_name", &self.network_profile_name);
formatter.field("room_arn", &self.room_arn);
formatter.field("room_name", &self.room_name);
formatter.field("device_status_info", &self.device_status_info);
formatter.field("created_time", &self.created_time);
formatter.finish()
}
}
pub mod device_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) device_serial_number: std::option::Option<std::string::String>,
pub(crate) device_type: std::option::Option<std::string::String>,
pub(crate) device_name: std::option::Option<std::string::String>,
pub(crate) software_version: std::option::Option<std::string::String>,
pub(crate) mac_address: std::option::Option<std::string::String>,
pub(crate) device_status: std::option::Option<crate::model::DeviceStatus>,
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
pub(crate) network_profile_name: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) room_name: std::option::Option<std::string::String>,
pub(crate) device_status_info: std::option::Option<crate::model::DeviceStatusInfo>,
pub(crate) created_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn device_serial_number(mut self, input: impl Into<std::string::String>) -> Self {
self.device_serial_number = Some(input.into());
self
}
pub fn set_device_serial_number(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.device_serial_number = input;
self
}
pub fn device_type(mut self, input: impl Into<std::string::String>) -> Self {
self.device_type = Some(input.into());
self
}
pub fn set_device_type(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_type = input;
self
}
pub fn device_name(mut self, input: impl Into<std::string::String>) -> Self {
self.device_name = Some(input.into());
self
}
pub fn set_device_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_name = input;
self
}
pub fn software_version(mut self, input: impl Into<std::string::String>) -> Self {
self.software_version = Some(input.into());
self
}
pub fn set_software_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.software_version = input;
self
}
pub fn mac_address(mut self, input: impl Into<std::string::String>) -> Self {
self.mac_address = Some(input.into());
self
}
pub fn set_mac_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.mac_address = input;
self
}
pub fn device_status(mut self, input: crate::model::DeviceStatus) -> Self {
self.device_status = Some(input);
self
}
pub fn set_device_status(
mut self,
input: std::option::Option<crate::model::DeviceStatus>,
) -> Self {
self.device_status = input;
self
}
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn network_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_name = Some(input.into());
self
}
pub fn set_network_profile_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_name = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn room_name(mut self, input: impl Into<std::string::String>) -> Self {
self.room_name = Some(input.into());
self
}
pub fn set_room_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_name = input;
self
}
pub fn device_status_info(mut self, input: crate::model::DeviceStatusInfo) -> Self {
self.device_status_info = Some(input);
self
}
pub fn set_device_status_info(
mut self,
input: std::option::Option<crate::model::DeviceStatusInfo>,
) -> Self {
self.device_status_info = input;
self
}
pub fn created_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.created_time = Some(input);
self
}
pub fn set_created_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.created_time = input;
self
}
pub fn build(self) -> crate::model::DeviceData {
crate::model::DeviceData {
device_arn: self.device_arn,
device_serial_number: self.device_serial_number,
device_type: self.device_type,
device_name: self.device_name,
software_version: self.software_version,
mac_address: self.mac_address,
device_status: self.device_status,
network_profile_arn: self.network_profile_arn,
network_profile_name: self.network_profile_name,
room_arn: self.room_arn,
room_name: self.room_name,
device_status_info: self.device_status_info,
created_time: self.created_time,
}
}
}
}
impl DeviceData {
pub fn builder() -> crate::model::device_data::Builder {
crate::model::device_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeviceStatusInfo {
pub device_status_details: std::option::Option<std::vec::Vec<crate::model::DeviceStatusDetail>>,
pub connection_status: std::option::Option<crate::model::ConnectionStatus>,
pub connection_status_updated_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl DeviceStatusInfo {
pub fn device_status_details(
&self,
) -> std::option::Option<&[crate::model::DeviceStatusDetail]> {
self.device_status_details.as_deref()
}
pub fn connection_status(&self) -> std::option::Option<&crate::model::ConnectionStatus> {
self.connection_status.as_ref()
}
pub fn connection_status_updated_time(
&self,
) -> std::option::Option<&aws_smithy_types::DateTime> {
self.connection_status_updated_time.as_ref()
}
}
impl std::fmt::Debug for DeviceStatusInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeviceStatusInfo");
formatter.field("device_status_details", &self.device_status_details);
formatter.field("connection_status", &self.connection_status);
formatter.field(
"connection_status_updated_time",
&self.connection_status_updated_time,
);
formatter.finish()
}
}
pub mod device_status_info {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_status_details:
std::option::Option<std::vec::Vec<crate::model::DeviceStatusDetail>>,
pub(crate) connection_status: std::option::Option<crate::model::ConnectionStatus>,
pub(crate) connection_status_updated_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
pub fn device_status_details(
mut self,
input: impl Into<crate::model::DeviceStatusDetail>,
) -> Self {
let mut v = self.device_status_details.unwrap_or_default();
v.push(input.into());
self.device_status_details = Some(v);
self
}
pub fn set_device_status_details(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DeviceStatusDetail>>,
) -> Self {
self.device_status_details = input;
self
}
pub fn connection_status(mut self, input: crate::model::ConnectionStatus) -> Self {
self.connection_status = Some(input);
self
}
pub fn set_connection_status(
mut self,
input: std::option::Option<crate::model::ConnectionStatus>,
) -> Self {
self.connection_status = input;
self
}
pub fn connection_status_updated_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.connection_status_updated_time = Some(input);
self
}
pub fn set_connection_status_updated_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.connection_status_updated_time = input;
self
}
pub fn build(self) -> crate::model::DeviceStatusInfo {
crate::model::DeviceStatusInfo {
device_status_details: self.device_status_details,
connection_status: self.connection_status,
connection_status_updated_time: self.connection_status_updated_time,
}
}
}
}
impl DeviceStatusInfo {
pub fn builder() -> crate::model::device_status_info::Builder {
crate::model::device_status_info::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum ConnectionStatus {
#[allow(missing_docs)] Offline,
#[allow(missing_docs)] Online,
Unknown(String),
}
impl std::convert::From<&str> for ConnectionStatus {
fn from(s: &str) -> Self {
match s {
"OFFLINE" => ConnectionStatus::Offline,
"ONLINE" => ConnectionStatus::Online,
other => ConnectionStatus::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for ConnectionStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ConnectionStatus::from(s))
}
}
impl ConnectionStatus {
pub fn as_str(&self) -> &str {
match self {
ConnectionStatus::Offline => "OFFLINE",
ConnectionStatus::Online => "ONLINE",
ConnectionStatus::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["OFFLINE", "ONLINE"]
}
}
impl AsRef<str> for ConnectionStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeviceStatusDetail {
pub feature: std::option::Option<crate::model::Feature>,
pub code: std::option::Option<crate::model::DeviceStatusDetailCode>,
}
impl DeviceStatusDetail {
pub fn feature(&self) -> std::option::Option<&crate::model::Feature> {
self.feature.as_ref()
}
pub fn code(&self) -> std::option::Option<&crate::model::DeviceStatusDetailCode> {
self.code.as_ref()
}
}
impl std::fmt::Debug for DeviceStatusDetail {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeviceStatusDetail");
formatter.field("feature", &self.feature);
formatter.field("code", &self.code);
formatter.finish()
}
}
pub mod device_status_detail {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) feature: std::option::Option<crate::model::Feature>,
pub(crate) code: std::option::Option<crate::model::DeviceStatusDetailCode>,
}
impl Builder {
pub fn feature(mut self, input: crate::model::Feature) -> Self {
self.feature = Some(input);
self
}
pub fn set_feature(mut self, input: std::option::Option<crate::model::Feature>) -> Self {
self.feature = input;
self
}
pub fn code(mut self, input: crate::model::DeviceStatusDetailCode) -> Self {
self.code = Some(input);
self
}
pub fn set_code(
mut self,
input: std::option::Option<crate::model::DeviceStatusDetailCode>,
) -> Self {
self.code = input;
self
}
pub fn build(self) -> crate::model::DeviceStatusDetail {
crate::model::DeviceStatusDetail {
feature: self.feature,
code: self.code,
}
}
}
}
impl DeviceStatusDetail {
pub fn builder() -> crate::model::device_status_detail::Builder {
crate::model::device_status_detail::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DeviceStatusDetailCode {
#[allow(missing_docs)] AssociationRejection,
#[allow(missing_docs)] AuthenticationFailure,
#[allow(missing_docs)] CertificateAuthorityAccessDenied,
#[allow(missing_docs)] CertificateIssuingLimitExceeded,
#[allow(missing_docs)] CredentialsAccessFailure,
#[allow(missing_docs)] DeviceSoftwareUpdateNeeded,
#[allow(missing_docs)] DeviceWasOffline,
#[allow(missing_docs)] DhcpFailure,
#[allow(missing_docs)] DnsFailure,
#[allow(missing_docs)] InternetUnavailable,
#[allow(missing_docs)] InvalidCertificateAuthority,
#[allow(missing_docs)] InvalidPasswordState,
#[allow(missing_docs)] NetworkProfileNotFound,
#[allow(missing_docs)] PasswordManagerAccessDenied,
#[allow(missing_docs)] PasswordNotFound,
#[allow(missing_docs)] TlsVersionMismatch,
#[allow(missing_docs)] UnknownFailure,
Unknown(String),
}
impl std::convert::From<&str> for DeviceStatusDetailCode {
fn from(s: &str) -> Self {
match s {
"ASSOCIATION_REJECTION" => DeviceStatusDetailCode::AssociationRejection,
"AUTHENTICATION_FAILURE" => DeviceStatusDetailCode::AuthenticationFailure,
"CERTIFICATE_AUTHORITY_ACCESS_DENIED" => {
DeviceStatusDetailCode::CertificateAuthorityAccessDenied
}
"CERTIFICATE_ISSUING_LIMIT_EXCEEDED" => {
DeviceStatusDetailCode::CertificateIssuingLimitExceeded
}
"CREDENTIALS_ACCESS_FAILURE" => DeviceStatusDetailCode::CredentialsAccessFailure,
"DEVICE_SOFTWARE_UPDATE_NEEDED" => DeviceStatusDetailCode::DeviceSoftwareUpdateNeeded,
"DEVICE_WAS_OFFLINE" => DeviceStatusDetailCode::DeviceWasOffline,
"DHCP_FAILURE" => DeviceStatusDetailCode::DhcpFailure,
"DNS_FAILURE" => DeviceStatusDetailCode::DnsFailure,
"INTERNET_UNAVAILABLE" => DeviceStatusDetailCode::InternetUnavailable,
"INVALID_CERTIFICATE_AUTHORITY" => DeviceStatusDetailCode::InvalidCertificateAuthority,
"INVALID_PASSWORD_STATE" => DeviceStatusDetailCode::InvalidPasswordState,
"NETWORK_PROFILE_NOT_FOUND" => DeviceStatusDetailCode::NetworkProfileNotFound,
"PASSWORD_MANAGER_ACCESS_DENIED" => DeviceStatusDetailCode::PasswordManagerAccessDenied,
"PASSWORD_NOT_FOUND" => DeviceStatusDetailCode::PasswordNotFound,
"TLS_VERSION_MISMATCH" => DeviceStatusDetailCode::TlsVersionMismatch,
"UNKNOWN_FAILURE" => DeviceStatusDetailCode::UnknownFailure,
other => DeviceStatusDetailCode::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for DeviceStatusDetailCode {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DeviceStatusDetailCode::from(s))
}
}
impl DeviceStatusDetailCode {
pub fn as_str(&self) -> &str {
match self {
DeviceStatusDetailCode::AssociationRejection => "ASSOCIATION_REJECTION",
DeviceStatusDetailCode::AuthenticationFailure => "AUTHENTICATION_FAILURE",
DeviceStatusDetailCode::CertificateAuthorityAccessDenied => {
"CERTIFICATE_AUTHORITY_ACCESS_DENIED"
}
DeviceStatusDetailCode::CertificateIssuingLimitExceeded => {
"CERTIFICATE_ISSUING_LIMIT_EXCEEDED"
}
DeviceStatusDetailCode::CredentialsAccessFailure => "CREDENTIALS_ACCESS_FAILURE",
DeviceStatusDetailCode::DeviceSoftwareUpdateNeeded => "DEVICE_SOFTWARE_UPDATE_NEEDED",
DeviceStatusDetailCode::DeviceWasOffline => "DEVICE_WAS_OFFLINE",
DeviceStatusDetailCode::DhcpFailure => "DHCP_FAILURE",
DeviceStatusDetailCode::DnsFailure => "DNS_FAILURE",
DeviceStatusDetailCode::InternetUnavailable => "INTERNET_UNAVAILABLE",
DeviceStatusDetailCode::InvalidCertificateAuthority => "INVALID_CERTIFICATE_AUTHORITY",
DeviceStatusDetailCode::InvalidPasswordState => "INVALID_PASSWORD_STATE",
DeviceStatusDetailCode::NetworkProfileNotFound => "NETWORK_PROFILE_NOT_FOUND",
DeviceStatusDetailCode::PasswordManagerAccessDenied => "PASSWORD_MANAGER_ACCESS_DENIED",
DeviceStatusDetailCode::PasswordNotFound => "PASSWORD_NOT_FOUND",
DeviceStatusDetailCode::TlsVersionMismatch => "TLS_VERSION_MISMATCH",
DeviceStatusDetailCode::UnknownFailure => "UNKNOWN_FAILURE",
DeviceStatusDetailCode::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&[
"ASSOCIATION_REJECTION",
"AUTHENTICATION_FAILURE",
"CERTIFICATE_AUTHORITY_ACCESS_DENIED",
"CERTIFICATE_ISSUING_LIMIT_EXCEEDED",
"CREDENTIALS_ACCESS_FAILURE",
"DEVICE_SOFTWARE_UPDATE_NEEDED",
"DEVICE_WAS_OFFLINE",
"DHCP_FAILURE",
"DNS_FAILURE",
"INTERNET_UNAVAILABLE",
"INVALID_CERTIFICATE_AUTHORITY",
"INVALID_PASSWORD_STATE",
"NETWORK_PROFILE_NOT_FOUND",
"PASSWORD_MANAGER_ACCESS_DENIED",
"PASSWORD_NOT_FOUND",
"TLS_VERSION_MISMATCH",
"UNKNOWN_FAILURE",
]
}
}
impl AsRef<str> for DeviceStatusDetailCode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DeviceStatus {
#[allow(missing_docs)] Deregistered,
#[allow(missing_docs)] Failed,
#[allow(missing_docs)] Pending,
#[allow(missing_docs)] Ready,
#[allow(missing_docs)] WasOffline,
Unknown(String),
}
impl std::convert::From<&str> for DeviceStatus {
fn from(s: &str) -> Self {
match s {
"DEREGISTERED" => DeviceStatus::Deregistered,
"FAILED" => DeviceStatus::Failed,
"PENDING" => DeviceStatus::Pending,
"READY" => DeviceStatus::Ready,
"WAS_OFFLINE" => DeviceStatus::WasOffline,
other => DeviceStatus::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for DeviceStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DeviceStatus::from(s))
}
}
impl DeviceStatus {
pub fn as_str(&self) -> &str {
match self {
DeviceStatus::Deregistered => "DEREGISTERED",
DeviceStatus::Failed => "FAILED",
DeviceStatus::Pending => "PENDING",
DeviceStatus::Ready => "READY",
DeviceStatus::WasOffline => "WAS_OFFLINE",
DeviceStatus::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["DEREGISTERED", "FAILED", "PENDING", "READY", "WAS_OFFLINE"]
}
}
impl AsRef<str> for DeviceStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ContactData {
pub contact_arn: std::option::Option<std::string::String>,
pub display_name: std::option::Option<std::string::String>,
pub first_name: std::option::Option<std::string::String>,
pub last_name: std::option::Option<std::string::String>,
pub phone_number: std::option::Option<std::string::String>,
pub phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
}
impl ContactData {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
pub fn display_name(&self) -> std::option::Option<&str> {
self.display_name.as_deref()
}
pub fn first_name(&self) -> std::option::Option<&str> {
self.first_name.as_deref()
}
pub fn last_name(&self) -> std::option::Option<&str> {
self.last_name.as_deref()
}
pub fn phone_number(&self) -> std::option::Option<&str> {
self.phone_number.as_deref()
}
pub fn phone_numbers(&self) -> std::option::Option<&[crate::model::PhoneNumber]> {
self.phone_numbers.as_deref()
}
pub fn sip_addresses(&self) -> std::option::Option<&[crate::model::SipAddress]> {
self.sip_addresses.as_deref()
}
}
impl std::fmt::Debug for ContactData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ContactData");
formatter.field("contact_arn", &self.contact_arn);
formatter.field("display_name", &self.display_name);
formatter.field("first_name", &self.first_name);
formatter.field("last_name", &self.last_name);
formatter.field("phone_number", &"*** Sensitive Data Redacted ***");
formatter.field("phone_numbers", &self.phone_numbers);
formatter.field("sip_addresses", &self.sip_addresses);
formatter.finish()
}
}
pub mod contact_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
pub(crate) display_name: std::option::Option<std::string::String>,
pub(crate) first_name: std::option::Option<std::string::String>,
pub(crate) last_name: std::option::Option<std::string::String>,
pub(crate) phone_number: std::option::Option<std::string::String>,
pub(crate) phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub(crate) sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
self.display_name = Some(input.into());
self
}
pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.display_name = input;
self
}
pub fn first_name(mut self, input: impl Into<std::string::String>) -> Self {
self.first_name = Some(input.into());
self
}
pub fn set_first_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.first_name = input;
self
}
pub fn last_name(mut self, input: impl Into<std::string::String>) -> Self {
self.last_name = Some(input.into());
self
}
pub fn set_last_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.last_name = input;
self
}
pub fn phone_number(mut self, input: impl Into<std::string::String>) -> Self {
self.phone_number = Some(input.into());
self
}
pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
self.phone_number = input;
self
}
pub fn phone_numbers(mut self, input: impl Into<crate::model::PhoneNumber>) -> Self {
let mut v = self.phone_numbers.unwrap_or_default();
v.push(input.into());
self.phone_numbers = Some(v);
self
}
pub fn set_phone_numbers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
) -> Self {
self.phone_numbers = input;
self
}
pub fn sip_addresses(mut self, input: impl Into<crate::model::SipAddress>) -> Self {
let mut v = self.sip_addresses.unwrap_or_default();
v.push(input.into());
self.sip_addresses = Some(v);
self
}
pub fn set_sip_addresses(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
) -> Self {
self.sip_addresses = input;
self
}
pub fn build(self) -> crate::model::ContactData {
crate::model::ContactData {
contact_arn: self.contact_arn,
display_name: self.display_name,
first_name: self.first_name,
last_name: self.last_name,
phone_number: self.phone_number,
phone_numbers: self.phone_numbers,
sip_addresses: self.sip_addresses,
}
}
}
}
impl ContactData {
pub fn builder() -> crate::model::contact_data::Builder {
crate::model::contact_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AddressBookData {
pub address_book_arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl AddressBookData {
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for AddressBookData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AddressBookData");
formatter.field("address_book_arn", &self.address_book_arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod address_book_data {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) address_book_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::AddressBookData {
crate::model::AddressBookData {
address_book_arn: self.address_book_arn,
name: self.name,
description: self.description,
}
}
}
}
impl AddressBookData {
pub fn builder() -> crate::model::address_book_data::Builder {
crate::model::address_book_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RoomSkillParameter {
pub parameter_key: std::option::Option<std::string::String>,
pub parameter_value: std::option::Option<std::string::String>,
}
impl RoomSkillParameter {
pub fn parameter_key(&self) -> std::option::Option<&str> {
self.parameter_key.as_deref()
}
pub fn parameter_value(&self) -> std::option::Option<&str> {
self.parameter_value.as_deref()
}
}
impl std::fmt::Debug for RoomSkillParameter {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RoomSkillParameter");
formatter.field("parameter_key", &self.parameter_key);
formatter.field("parameter_value", &self.parameter_value);
formatter.finish()
}
}
pub mod room_skill_parameter {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_key: std::option::Option<std::string::String>,
pub(crate) parameter_value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn parameter_key(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_key = Some(input.into());
self
}
pub fn set_parameter_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_key = input;
self
}
pub fn parameter_value(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_value = Some(input.into());
self
}
pub fn set_parameter_value(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_value = input;
self
}
pub fn build(self) -> crate::model::RoomSkillParameter {
crate::model::RoomSkillParameter {
parameter_key: self.parameter_key,
parameter_value: self.parameter_value,
}
}
}
}
impl RoomSkillParameter {
pub fn builder() -> crate::model::room_skill_parameter::Builder {
crate::model::room_skill_parameter::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ConferencePreference {
pub default_conference_provider_arn: std::option::Option<std::string::String>,
}
impl ConferencePreference {
pub fn default_conference_provider_arn(&self) -> std::option::Option<&str> {
self.default_conference_provider_arn.as_deref()
}
}
impl std::fmt::Debug for ConferencePreference {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ConferencePreference");
formatter.field(
"default_conference_provider_arn",
&self.default_conference_provider_arn,
);
formatter.finish()
}
}
pub mod conference_preference {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) default_conference_provider_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn default_conference_provider_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.default_conference_provider_arn = Some(input.into());
self
}
pub fn set_default_conference_provider_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.default_conference_provider_arn = input;
self
}
pub fn build(self) -> crate::model::ConferencePreference {
crate::model::ConferencePreference {
default_conference_provider_arn: self.default_conference_provider_arn,
}
}
}
}
impl ConferencePreference {
pub fn builder() -> crate::model::conference_preference::Builder {
crate::model::conference_preference::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SmartHomeAppliance {
pub friendly_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub manufacturer_name: std::option::Option<std::string::String>,
}
impl SmartHomeAppliance {
pub fn friendly_name(&self) -> std::option::Option<&str> {
self.friendly_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn manufacturer_name(&self) -> std::option::Option<&str> {
self.manufacturer_name.as_deref()
}
}
impl std::fmt::Debug for SmartHomeAppliance {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SmartHomeAppliance");
formatter.field("friendly_name", &self.friendly_name);
formatter.field("description", &self.description);
formatter.field("manufacturer_name", &self.manufacturer_name);
formatter.finish()
}
}
pub mod smart_home_appliance {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) friendly_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) manufacturer_name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn friendly_name(mut self, input: impl Into<std::string::String>) -> Self {
self.friendly_name = Some(input.into());
self
}
pub fn set_friendly_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.friendly_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn manufacturer_name(mut self, input: impl Into<std::string::String>) -> Self {
self.manufacturer_name = Some(input.into());
self
}
pub fn set_manufacturer_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.manufacturer_name = input;
self
}
pub fn build(self) -> crate::model::SmartHomeAppliance {
crate::model::SmartHomeAppliance {
friendly_name: self.friendly_name,
description: self.description,
manufacturer_name: self.manufacturer_name,
}
}
}
}
impl SmartHomeAppliance {
pub fn builder() -> crate::model::smart_home_appliance::Builder {
crate::model::smart_home_appliance::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SkillsStoreSkill {
pub skill_id: std::option::Option<std::string::String>,
pub skill_name: std::option::Option<std::string::String>,
pub short_description: std::option::Option<std::string::String>,
pub icon_url: std::option::Option<std::string::String>,
pub sample_utterances: std::option::Option<std::vec::Vec<std::string::String>>,
pub skill_details: std::option::Option<crate::model::SkillDetails>,
pub supports_linking: bool,
}
impl SkillsStoreSkill {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn skill_name(&self) -> std::option::Option<&str> {
self.skill_name.as_deref()
}
pub fn short_description(&self) -> std::option::Option<&str> {
self.short_description.as_deref()
}
pub fn icon_url(&self) -> std::option::Option<&str> {
self.icon_url.as_deref()
}
pub fn sample_utterances(&self) -> std::option::Option<&[std::string::String]> {
self.sample_utterances.as_deref()
}
pub fn skill_details(&self) -> std::option::Option<&crate::model::SkillDetails> {
self.skill_details.as_ref()
}
pub fn supports_linking(&self) -> bool {
self.supports_linking
}
}
impl std::fmt::Debug for SkillsStoreSkill {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SkillsStoreSkill");
formatter.field("skill_id", &self.skill_id);
formatter.field("skill_name", &self.skill_name);
formatter.field("short_description", &self.short_description);
formatter.field("icon_url", &self.icon_url);
formatter.field("sample_utterances", &self.sample_utterances);
formatter.field("skill_details", &self.skill_details);
formatter.field("supports_linking", &self.supports_linking);
formatter.finish()
}
}
pub mod skills_store_skill {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) skill_name: std::option::Option<std::string::String>,
pub(crate) short_description: std::option::Option<std::string::String>,
pub(crate) icon_url: std::option::Option<std::string::String>,
pub(crate) sample_utterances: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) skill_details: std::option::Option<crate::model::SkillDetails>,
pub(crate) supports_linking: std::option::Option<bool>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn skill_name(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_name = Some(input.into());
self
}
pub fn set_skill_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_name = input;
self
}
pub fn short_description(mut self, input: impl Into<std::string::String>) -> Self {
self.short_description = Some(input.into());
self
}
pub fn set_short_description(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.short_description = input;
self
}
pub fn icon_url(mut self, input: impl Into<std::string::String>) -> Self {
self.icon_url = Some(input.into());
self
}
pub fn set_icon_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.icon_url = input;
self
}
pub fn sample_utterances(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.sample_utterances.unwrap_or_default();
v.push(input.into());
self.sample_utterances = Some(v);
self
}
pub fn set_sample_utterances(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.sample_utterances = input;
self
}
pub fn skill_details(mut self, input: crate::model::SkillDetails) -> Self {
self.skill_details = Some(input);
self
}
pub fn set_skill_details(
mut self,
input: std::option::Option<crate::model::SkillDetails>,
) -> Self {
self.skill_details = input;
self
}
pub fn supports_linking(mut self, input: bool) -> Self {
self.supports_linking = Some(input);
self
}
pub fn set_supports_linking(mut self, input: std::option::Option<bool>) -> Self {
self.supports_linking = input;
self
}
pub fn build(self) -> crate::model::SkillsStoreSkill {
crate::model::SkillsStoreSkill {
skill_id: self.skill_id,
skill_name: self.skill_name,
short_description: self.short_description,
icon_url: self.icon_url,
sample_utterances: self.sample_utterances,
skill_details: self.skill_details,
supports_linking: self.supports_linking.unwrap_or_default(),
}
}
}
}
impl SkillsStoreSkill {
pub fn builder() -> crate::model::skills_store_skill::Builder {
crate::model::skills_store_skill::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SkillDetails {
pub product_description: std::option::Option<std::string::String>,
pub invocation_phrase: std::option::Option<std::string::String>,
pub release_date: std::option::Option<std::string::String>,
pub end_user_license_agreement: std::option::Option<std::string::String>,
pub generic_keywords: std::option::Option<std::vec::Vec<std::string::String>>,
pub bullet_points: std::option::Option<std::vec::Vec<std::string::String>>,
pub new_in_this_version_bullet_points: std::option::Option<std::vec::Vec<std::string::String>>,
pub skill_types: std::option::Option<std::vec::Vec<std::string::String>>,
pub reviews:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
pub developer_info: std::option::Option<crate::model::DeveloperInfo>,
}
impl SkillDetails {
pub fn product_description(&self) -> std::option::Option<&str> {
self.product_description.as_deref()
}
pub fn invocation_phrase(&self) -> std::option::Option<&str> {
self.invocation_phrase.as_deref()
}
pub fn release_date(&self) -> std::option::Option<&str> {
self.release_date.as_deref()
}
pub fn end_user_license_agreement(&self) -> std::option::Option<&str> {
self.end_user_license_agreement.as_deref()
}
pub fn generic_keywords(&self) -> std::option::Option<&[std::string::String]> {
self.generic_keywords.as_deref()
}
pub fn bullet_points(&self) -> std::option::Option<&[std::string::String]> {
self.bullet_points.as_deref()
}
pub fn new_in_this_version_bullet_points(&self) -> std::option::Option<&[std::string::String]> {
self.new_in_this_version_bullet_points.as_deref()
}
pub fn skill_types(&self) -> std::option::Option<&[std::string::String]> {
self.skill_types.as_deref()
}
pub fn reviews(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.reviews.as_ref()
}
pub fn developer_info(&self) -> std::option::Option<&crate::model::DeveloperInfo> {
self.developer_info.as_ref()
}
}
impl std::fmt::Debug for SkillDetails {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SkillDetails");
formatter.field("product_description", &self.product_description);
formatter.field("invocation_phrase", &self.invocation_phrase);
formatter.field("release_date", &self.release_date);
formatter.field(
"end_user_license_agreement",
&self.end_user_license_agreement,
);
formatter.field("generic_keywords", &self.generic_keywords);
formatter.field("bullet_points", &self.bullet_points);
formatter.field(
"new_in_this_version_bullet_points",
&self.new_in_this_version_bullet_points,
);
formatter.field("skill_types", &self.skill_types);
formatter.field("reviews", &self.reviews);
formatter.field("developer_info", &self.developer_info);
formatter.finish()
}
}
pub mod skill_details {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) product_description: std::option::Option<std::string::String>,
pub(crate) invocation_phrase: std::option::Option<std::string::String>,
pub(crate) release_date: std::option::Option<std::string::String>,
pub(crate) end_user_license_agreement: std::option::Option<std::string::String>,
pub(crate) generic_keywords: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) bullet_points: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) new_in_this_version_bullet_points:
std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) skill_types: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) reviews: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) developer_info: std::option::Option<crate::model::DeveloperInfo>,
}
impl Builder {
pub fn product_description(mut self, input: impl Into<std::string::String>) -> Self {
self.product_description = Some(input.into());
self
}
pub fn set_product_description(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.product_description = input;
self
}
pub fn invocation_phrase(mut self, input: impl Into<std::string::String>) -> Self {
self.invocation_phrase = Some(input.into());
self
}
pub fn set_invocation_phrase(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.invocation_phrase = input;
self
}
pub fn release_date(mut self, input: impl Into<std::string::String>) -> Self {
self.release_date = Some(input.into());
self
}
pub fn set_release_date(mut self, input: std::option::Option<std::string::String>) -> Self {
self.release_date = input;
self
}
pub fn end_user_license_agreement(mut self, input: impl Into<std::string::String>) -> Self {
self.end_user_license_agreement = Some(input.into());
self
}
pub fn set_end_user_license_agreement(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.end_user_license_agreement = input;
self
}
pub fn generic_keywords(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.generic_keywords.unwrap_or_default();
v.push(input.into());
self.generic_keywords = Some(v);
self
}
pub fn set_generic_keywords(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.generic_keywords = input;
self
}
pub fn bullet_points(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.bullet_points.unwrap_or_default();
v.push(input.into());
self.bullet_points = Some(v);
self
}
pub fn set_bullet_points(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.bullet_points = input;
self
}
pub fn new_in_this_version_bullet_points(
mut self,
input: impl Into<std::string::String>,
) -> Self {
let mut v = self.new_in_this_version_bullet_points.unwrap_or_default();
v.push(input.into());
self.new_in_this_version_bullet_points = Some(v);
self
}
pub fn set_new_in_this_version_bullet_points(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.new_in_this_version_bullet_points = input;
self
}
pub fn skill_types(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.skill_types.unwrap_or_default();
v.push(input.into());
self.skill_types = Some(v);
self
}
pub fn set_skill_types(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.skill_types = input;
self
}
pub fn reviews(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.reviews.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.reviews = Some(hash_map);
self
}
pub fn set_reviews(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.reviews = input;
self
}
pub fn developer_info(mut self, input: crate::model::DeveloperInfo) -> Self {
self.developer_info = Some(input);
self
}
pub fn set_developer_info(
mut self,
input: std::option::Option<crate::model::DeveloperInfo>,
) -> Self {
self.developer_info = input;
self
}
pub fn build(self) -> crate::model::SkillDetails {
crate::model::SkillDetails {
product_description: self.product_description,
invocation_phrase: self.invocation_phrase,
release_date: self.release_date,
end_user_license_agreement: self.end_user_license_agreement,
generic_keywords: self.generic_keywords,
bullet_points: self.bullet_points,
new_in_this_version_bullet_points: self.new_in_this_version_bullet_points,
skill_types: self.skill_types,
reviews: self.reviews,
developer_info: self.developer_info,
}
}
}
}
impl SkillDetails {
pub fn builder() -> crate::model::skill_details::Builder {
crate::model::skill_details::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeveloperInfo {
pub developer_name: std::option::Option<std::string::String>,
pub privacy_policy: std::option::Option<std::string::String>,
pub email: std::option::Option<std::string::String>,
pub url: std::option::Option<std::string::String>,
}
impl DeveloperInfo {
pub fn developer_name(&self) -> std::option::Option<&str> {
self.developer_name.as_deref()
}
pub fn privacy_policy(&self) -> std::option::Option<&str> {
self.privacy_policy.as_deref()
}
pub fn email(&self) -> std::option::Option<&str> {
self.email.as_deref()
}
pub fn url(&self) -> std::option::Option<&str> {
self.url.as_deref()
}
}
impl std::fmt::Debug for DeveloperInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeveloperInfo");
formatter.field("developer_name", &self.developer_name);
formatter.field("privacy_policy", &self.privacy_policy);
formatter.field("email", &self.email);
formatter.field("url", &self.url);
formatter.finish()
}
}
pub mod developer_info {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) developer_name: std::option::Option<std::string::String>,
pub(crate) privacy_policy: std::option::Option<std::string::String>,
pub(crate) email: std::option::Option<std::string::String>,
pub(crate) url: std::option::Option<std::string::String>,
}
impl Builder {
pub fn developer_name(mut self, input: impl Into<std::string::String>) -> Self {
self.developer_name = Some(input.into());
self
}
pub fn set_developer_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.developer_name = input;
self
}
pub fn privacy_policy(mut self, input: impl Into<std::string::String>) -> Self {
self.privacy_policy = Some(input.into());
self
}
pub fn set_privacy_policy(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.privacy_policy = input;
self
}
pub fn email(mut self, input: impl Into<std::string::String>) -> Self {
self.email = Some(input.into());
self
}
pub fn set_email(mut self, input: std::option::Option<std::string::String>) -> Self {
self.email = input;
self
}
pub fn url(mut self, input: impl Into<std::string::String>) -> Self {
self.url = Some(input.into());
self
}
pub fn set_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.url = input;
self
}
pub fn build(self) -> crate::model::DeveloperInfo {
crate::model::DeveloperInfo {
developer_name: self.developer_name,
privacy_policy: self.privacy_policy,
email: self.email,
url: self.url,
}
}
}
}
impl DeveloperInfo {
pub fn builder() -> crate::model::developer_info::Builder {
crate::model::developer_info::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Category {
pub category_id: std::option::Option<i64>,
pub category_name: std::option::Option<std::string::String>,
}
impl Category {
pub fn category_id(&self) -> std::option::Option<i64> {
self.category_id
}
pub fn category_name(&self) -> std::option::Option<&str> {
self.category_name.as_deref()
}
}
impl std::fmt::Debug for Category {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Category");
formatter.field("category_id", &self.category_id);
formatter.field("category_name", &self.category_name);
formatter.finish()
}
}
pub mod category {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) category_id: std::option::Option<i64>,
pub(crate) category_name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn category_id(mut self, input: i64) -> Self {
self.category_id = Some(input);
self
}
pub fn set_category_id(mut self, input: std::option::Option<i64>) -> Self {
self.category_id = input;
self
}
pub fn category_name(mut self, input: impl Into<std::string::String>) -> Self {
self.category_name = Some(input.into());
self
}
pub fn set_category_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.category_name = input;
self
}
pub fn build(self) -> crate::model::Category {
crate::model::Category {
category_id: self.category_id,
category_name: self.category_name,
}
}
}
}
impl Category {
pub fn builder() -> crate::model::category::Builder {
crate::model::category::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SkillSummary {
pub skill_id: std::option::Option<std::string::String>,
pub skill_name: std::option::Option<std::string::String>,
pub supports_linking: bool,
pub enablement_type: std::option::Option<crate::model::EnablementType>,
pub skill_type: std::option::Option<crate::model::SkillType>,
}
impl SkillSummary {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn skill_name(&self) -> std::option::Option<&str> {
self.skill_name.as_deref()
}
pub fn supports_linking(&self) -> bool {
self.supports_linking
}
pub fn enablement_type(&self) -> std::option::Option<&crate::model::EnablementType> {
self.enablement_type.as_ref()
}
pub fn skill_type(&self) -> std::option::Option<&crate::model::SkillType> {
self.skill_type.as_ref()
}
}
impl std::fmt::Debug for SkillSummary {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SkillSummary");
formatter.field("skill_id", &self.skill_id);
formatter.field("skill_name", &self.skill_name);
formatter.field("supports_linking", &self.supports_linking);
formatter.field("enablement_type", &self.enablement_type);
formatter.field("skill_type", &self.skill_type);
formatter.finish()
}
}
pub mod skill_summary {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) skill_name: std::option::Option<std::string::String>,
pub(crate) supports_linking: std::option::Option<bool>,
pub(crate) enablement_type: std::option::Option<crate::model::EnablementType>,
pub(crate) skill_type: std::option::Option<crate::model::SkillType>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn skill_name(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_name = Some(input.into());
self
}
pub fn set_skill_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_name = input;
self
}
pub fn supports_linking(mut self, input: bool) -> Self {
self.supports_linking = Some(input);
self
}
pub fn set_supports_linking(mut self, input: std::option::Option<bool>) -> Self {
self.supports_linking = input;
self
}
pub fn enablement_type(mut self, input: crate::model::EnablementType) -> Self {
self.enablement_type = Some(input);
self
}
pub fn set_enablement_type(
mut self,
input: std::option::Option<crate::model::EnablementType>,
) -> Self {
self.enablement_type = input;
self
}
pub fn skill_type(mut self, input: crate::model::SkillType) -> Self {
self.skill_type = Some(input);
self
}
pub fn set_skill_type(
mut self,
input: std::option::Option<crate::model::SkillType>,
) -> Self {
self.skill_type = input;
self
}
pub fn build(self) -> crate::model::SkillSummary {
crate::model::SkillSummary {
skill_id: self.skill_id,
skill_name: self.skill_name,
supports_linking: self.supports_linking.unwrap_or_default(),
enablement_type: self.enablement_type,
skill_type: self.skill_type,
}
}
}
}
impl SkillSummary {
pub fn builder() -> crate::model::skill_summary::Builder {
crate::model::skill_summary::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum SkillType {
#[allow(missing_docs)] Private,
#[allow(missing_docs)] Public,
Unknown(String),
}
impl std::convert::From<&str> for SkillType {
fn from(s: &str) -> Self {
match s {
"PRIVATE" => SkillType::Private,
"PUBLIC" => SkillType::Public,
other => SkillType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for SkillType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SkillType::from(s))
}
}
impl SkillType {
pub fn as_str(&self) -> &str {
match self {
SkillType::Private => "PRIVATE",
SkillType::Public => "PUBLIC",
SkillType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["PRIVATE", "PUBLIC"]
}
}
impl AsRef<str> for SkillType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum EnablementType {
#[allow(missing_docs)] Enabled,
#[allow(missing_docs)] Pending,
Unknown(String),
}
impl std::convert::From<&str> for EnablementType {
fn from(s: &str) -> Self {
match s {
"ENABLED" => EnablementType::Enabled,
"PENDING" => EnablementType::Pending,
other => EnablementType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for EnablementType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(EnablementType::from(s))
}
}
impl EnablementType {
pub fn as_str(&self) -> &str {
match self {
EnablementType::Enabled => "ENABLED",
EnablementType::Pending => "PENDING",
EnablementType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ENABLED", "PENDING"]
}
}
impl AsRef<str> for EnablementType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum SkillTypeFilter {
#[allow(missing_docs)] All,
#[allow(missing_docs)] Private,
#[allow(missing_docs)] Public,
Unknown(String),
}
impl std::convert::From<&str> for SkillTypeFilter {
fn from(s: &str) -> Self {
match s {
"ALL" => SkillTypeFilter::All,
"PRIVATE" => SkillTypeFilter::Private,
"PUBLIC" => SkillTypeFilter::Public,
other => SkillTypeFilter::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for SkillTypeFilter {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SkillTypeFilter::from(s))
}
}
impl SkillTypeFilter {
pub fn as_str(&self) -> &str {
match self {
SkillTypeFilter::All => "ALL",
SkillTypeFilter::Private => "PRIVATE",
SkillTypeFilter::Public => "PUBLIC",
SkillTypeFilter::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ALL", "PRIVATE", "PUBLIC"]
}
}
impl AsRef<str> for SkillTypeFilter {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum EnablementTypeFilter {
#[allow(missing_docs)] Enabled,
#[allow(missing_docs)] Pending,
Unknown(String),
}
impl std::convert::From<&str> for EnablementTypeFilter {
fn from(s: &str) -> Self {
match s {
"ENABLED" => EnablementTypeFilter::Enabled,
"PENDING" => EnablementTypeFilter::Pending,
other => EnablementTypeFilter::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for EnablementTypeFilter {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(EnablementTypeFilter::from(s))
}
}
impl EnablementTypeFilter {
pub fn as_str(&self) -> &str {
match self {
EnablementTypeFilter::Enabled => "ENABLED",
EnablementTypeFilter::Pending => "PENDING",
EnablementTypeFilter::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ENABLED", "PENDING"]
}
}
impl AsRef<str> for EnablementTypeFilter {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GatewaySummary {
pub arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub gateway_group_arn: std::option::Option<std::string::String>,
pub software_version: std::option::Option<std::string::String>,
}
impl GatewaySummary {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn gateway_group_arn(&self) -> std::option::Option<&str> {
self.gateway_group_arn.as_deref()
}
pub fn software_version(&self) -> std::option::Option<&str> {
self.software_version.as_deref()
}
}
impl std::fmt::Debug for GatewaySummary {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GatewaySummary");
formatter.field("arn", &self.arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("gateway_group_arn", &self.gateway_group_arn);
formatter.field("software_version", &self.software_version);
formatter.finish()
}
}
pub mod gateway_summary {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) gateway_group_arn: std::option::Option<std::string::String>,
pub(crate) software_version: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn gateway_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_group_arn = Some(input.into());
self
}
pub fn set_gateway_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.gateway_group_arn = input;
self
}
pub fn software_version(mut self, input: impl Into<std::string::String>) -> Self {
self.software_version = Some(input.into());
self
}
pub fn set_software_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.software_version = input;
self
}
pub fn build(self) -> crate::model::GatewaySummary {
crate::model::GatewaySummary {
arn: self.arn,
name: self.name,
description: self.description,
gateway_group_arn: self.gateway_group_arn,
software_version: self.software_version,
}
}
}
}
impl GatewaySummary {
pub fn builder() -> crate::model::gateway_summary::Builder {
crate::model::gateway_summary::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GatewayGroupSummary {
pub arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl GatewayGroupSummary {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for GatewayGroupSummary {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GatewayGroupSummary");
formatter.field("arn", &self.arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod gateway_group_summary {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::GatewayGroupSummary {
crate::model::GatewayGroupSummary {
arn: self.arn,
name: self.name,
description: self.description,
}
}
}
}
impl GatewayGroupSummary {
pub fn builder() -> crate::model::gateway_group_summary::Builder {
crate::model::gateway_group_summary::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeviceEvent {
pub r#type: std::option::Option<crate::model::DeviceEventType>,
pub value: std::option::Option<std::string::String>,
pub timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl DeviceEvent {
pub fn r#type(&self) -> std::option::Option<&crate::model::DeviceEventType> {
self.r#type.as_ref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
pub fn timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.timestamp.as_ref()
}
}
impl std::fmt::Debug for DeviceEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeviceEvent");
formatter.field("r#type", &self.r#type);
formatter.field("value", &self.value);
formatter.field("timestamp", &self.timestamp);
formatter.finish()
}
}
pub mod device_event {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) r#type: std::option::Option<crate::model::DeviceEventType>,
pub(crate) value: std::option::Option<std::string::String>,
pub(crate) timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
pub fn r#type(mut self, input: crate::model::DeviceEventType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(
mut self,
input: std::option::Option<crate::model::DeviceEventType>,
) -> Self {
self.r#type = input;
self
}
pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
self.value = Some(input.into());
self
}
pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
self.value = input;
self
}
pub fn timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.timestamp = Some(input);
self
}
pub fn set_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.timestamp = input;
self
}
pub fn build(self) -> crate::model::DeviceEvent {
crate::model::DeviceEvent {
r#type: self.r#type,
value: self.value,
timestamp: self.timestamp,
}
}
}
}
impl DeviceEvent {
pub fn builder() -> crate::model::device_event::Builder {
crate::model::device_event::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DeviceEventType {
#[allow(missing_docs)] ConnectionStatus,
#[allow(missing_docs)] DeviceStatus,
Unknown(String),
}
impl std::convert::From<&str> for DeviceEventType {
fn from(s: &str) -> Self {
match s {
"CONNECTION_STATUS" => DeviceEventType::ConnectionStatus,
"DEVICE_STATUS" => DeviceEventType::DeviceStatus,
other => DeviceEventType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for DeviceEventType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DeviceEventType::from(s))
}
}
impl DeviceEventType {
pub fn as_str(&self) -> &str {
match self {
DeviceEventType::ConnectionStatus => "CONNECTION_STATUS",
DeviceEventType::DeviceStatus => "DEVICE_STATUS",
DeviceEventType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["CONNECTION_STATUS", "DEVICE_STATUS"]
}
}
impl AsRef<str> for DeviceEventType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ConferenceProvider {
pub arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub r#type: std::option::Option<crate::model::ConferenceProviderType>,
pub ip_dial_in: std::option::Option<crate::model::IpDialIn>,
pub pstn_dial_in: std::option::Option<crate::model::PstnDialIn>,
pub meeting_setting: std::option::Option<crate::model::MeetingSetting>,
}
impl ConferenceProvider {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn r#type(&self) -> std::option::Option<&crate::model::ConferenceProviderType> {
self.r#type.as_ref()
}
pub fn ip_dial_in(&self) -> std::option::Option<&crate::model::IpDialIn> {
self.ip_dial_in.as_ref()
}
pub fn pstn_dial_in(&self) -> std::option::Option<&crate::model::PstnDialIn> {
self.pstn_dial_in.as_ref()
}
pub fn meeting_setting(&self) -> std::option::Option<&crate::model::MeetingSetting> {
self.meeting_setting.as_ref()
}
}
impl std::fmt::Debug for ConferenceProvider {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ConferenceProvider");
formatter.field("arn", &self.arn);
formatter.field("name", &self.name);
formatter.field("r#type", &self.r#type);
formatter.field("ip_dial_in", &self.ip_dial_in);
formatter.field("pstn_dial_in", &self.pstn_dial_in);
formatter.field("meeting_setting", &self.meeting_setting);
formatter.finish()
}
}
pub mod conference_provider {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) r#type: std::option::Option<crate::model::ConferenceProviderType>,
pub(crate) ip_dial_in: std::option::Option<crate::model::IpDialIn>,
pub(crate) pstn_dial_in: std::option::Option<crate::model::PstnDialIn>,
pub(crate) meeting_setting: std::option::Option<crate::model::MeetingSetting>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn r#type(mut self, input: crate::model::ConferenceProviderType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(
mut self,
input: std::option::Option<crate::model::ConferenceProviderType>,
) -> Self {
self.r#type = input;
self
}
pub fn ip_dial_in(mut self, input: crate::model::IpDialIn) -> Self {
self.ip_dial_in = Some(input);
self
}
pub fn set_ip_dial_in(
mut self,
input: std::option::Option<crate::model::IpDialIn>,
) -> Self {
self.ip_dial_in = input;
self
}
pub fn pstn_dial_in(mut self, input: crate::model::PstnDialIn) -> Self {
self.pstn_dial_in = Some(input);
self
}
pub fn set_pstn_dial_in(
mut self,
input: std::option::Option<crate::model::PstnDialIn>,
) -> Self {
self.pstn_dial_in = input;
self
}
pub fn meeting_setting(mut self, input: crate::model::MeetingSetting) -> Self {
self.meeting_setting = Some(input);
self
}
pub fn set_meeting_setting(
mut self,
input: std::option::Option<crate::model::MeetingSetting>,
) -> Self {
self.meeting_setting = input;
self
}
pub fn build(self) -> crate::model::ConferenceProvider {
crate::model::ConferenceProvider {
arn: self.arn,
name: self.name,
r#type: self.r#type,
ip_dial_in: self.ip_dial_in,
pstn_dial_in: self.pstn_dial_in,
meeting_setting: self.meeting_setting,
}
}
}
}
impl ConferenceProvider {
pub fn builder() -> crate::model::conference_provider::Builder {
crate::model::conference_provider::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BusinessReportSchedule {
pub schedule_arn: std::option::Option<std::string::String>,
pub schedule_name: std::option::Option<std::string::String>,
pub s3_bucket_name: std::option::Option<std::string::String>,
pub s3_key_prefix: std::option::Option<std::string::String>,
pub format: std::option::Option<crate::model::BusinessReportFormat>,
pub content_range: std::option::Option<crate::model::BusinessReportContentRange>,
pub recurrence: std::option::Option<crate::model::BusinessReportRecurrence>,
pub last_business_report: std::option::Option<crate::model::BusinessReport>,
}
impl BusinessReportSchedule {
pub fn schedule_arn(&self) -> std::option::Option<&str> {
self.schedule_arn.as_deref()
}
pub fn schedule_name(&self) -> std::option::Option<&str> {
self.schedule_name.as_deref()
}
pub fn s3_bucket_name(&self) -> std::option::Option<&str> {
self.s3_bucket_name.as_deref()
}
pub fn s3_key_prefix(&self) -> std::option::Option<&str> {
self.s3_key_prefix.as_deref()
}
pub fn format(&self) -> std::option::Option<&crate::model::BusinessReportFormat> {
self.format.as_ref()
}
pub fn content_range(&self) -> std::option::Option<&crate::model::BusinessReportContentRange> {
self.content_range.as_ref()
}
pub fn recurrence(&self) -> std::option::Option<&crate::model::BusinessReportRecurrence> {
self.recurrence.as_ref()
}
pub fn last_business_report(&self) -> std::option::Option<&crate::model::BusinessReport> {
self.last_business_report.as_ref()
}
}
impl std::fmt::Debug for BusinessReportSchedule {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("BusinessReportSchedule");
formatter.field("schedule_arn", &self.schedule_arn);
formatter.field("schedule_name", &self.schedule_name);
formatter.field("s3_bucket_name", &self.s3_bucket_name);
formatter.field("s3_key_prefix", &self.s3_key_prefix);
formatter.field("format", &self.format);
formatter.field("content_range", &self.content_range);
formatter.field("recurrence", &self.recurrence);
formatter.field("last_business_report", &self.last_business_report);
formatter.finish()
}
}
pub mod business_report_schedule {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) schedule_arn: std::option::Option<std::string::String>,
pub(crate) schedule_name: std::option::Option<std::string::String>,
pub(crate) s3_bucket_name: std::option::Option<std::string::String>,
pub(crate) s3_key_prefix: std::option::Option<std::string::String>,
pub(crate) format: std::option::Option<crate::model::BusinessReportFormat>,
pub(crate) content_range: std::option::Option<crate::model::BusinessReportContentRange>,
pub(crate) recurrence: std::option::Option<crate::model::BusinessReportRecurrence>,
pub(crate) last_business_report: std::option::Option<crate::model::BusinessReport>,
}
impl Builder {
pub fn schedule_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule_arn = Some(input.into());
self
}
pub fn set_schedule_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule_arn = input;
self
}
pub fn schedule_name(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule_name = Some(input.into());
self
}
pub fn set_schedule_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schedule_name = input;
self
}
pub fn s3_bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_bucket_name = Some(input.into());
self
}
pub fn set_s3_bucket_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.s3_bucket_name = input;
self
}
pub fn s3_key_prefix(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_key_prefix = Some(input.into());
self
}
pub fn set_s3_key_prefix(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.s3_key_prefix = input;
self
}
pub fn format(mut self, input: crate::model::BusinessReportFormat) -> Self {
self.format = Some(input);
self
}
pub fn set_format(
mut self,
input: std::option::Option<crate::model::BusinessReportFormat>,
) -> Self {
self.format = input;
self
}
pub fn content_range(mut self, input: crate::model::BusinessReportContentRange) -> Self {
self.content_range = Some(input);
self
}
pub fn set_content_range(
mut self,
input: std::option::Option<crate::model::BusinessReportContentRange>,
) -> Self {
self.content_range = input;
self
}
pub fn recurrence(mut self, input: crate::model::BusinessReportRecurrence) -> Self {
self.recurrence = Some(input);
self
}
pub fn set_recurrence(
mut self,
input: std::option::Option<crate::model::BusinessReportRecurrence>,
) -> Self {
self.recurrence = input;
self
}
pub fn last_business_report(mut self, input: crate::model::BusinessReport) -> Self {
self.last_business_report = Some(input);
self
}
pub fn set_last_business_report(
mut self,
input: std::option::Option<crate::model::BusinessReport>,
) -> Self {
self.last_business_report = input;
self
}
pub fn build(self) -> crate::model::BusinessReportSchedule {
crate::model::BusinessReportSchedule {
schedule_arn: self.schedule_arn,
schedule_name: self.schedule_name,
s3_bucket_name: self.s3_bucket_name,
s3_key_prefix: self.s3_key_prefix,
format: self.format,
content_range: self.content_range,
recurrence: self.recurrence,
last_business_report: self.last_business_report,
}
}
}
}
impl BusinessReportSchedule {
pub fn builder() -> crate::model::business_report_schedule::Builder {
crate::model::business_report_schedule::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BusinessReport {
pub status: std::option::Option<crate::model::BusinessReportStatus>,
pub failure_code: std::option::Option<crate::model::BusinessReportFailureCode>,
pub s3_location: std::option::Option<crate::model::BusinessReportS3Location>,
pub delivery_time: std::option::Option<aws_smithy_types::DateTime>,
pub download_url: std::option::Option<std::string::String>,
}
impl BusinessReport {
pub fn status(&self) -> std::option::Option<&crate::model::BusinessReportStatus> {
self.status.as_ref()
}
pub fn failure_code(&self) -> std::option::Option<&crate::model::BusinessReportFailureCode> {
self.failure_code.as_ref()
}
pub fn s3_location(&self) -> std::option::Option<&crate::model::BusinessReportS3Location> {
self.s3_location.as_ref()
}
pub fn delivery_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.delivery_time.as_ref()
}
pub fn download_url(&self) -> std::option::Option<&str> {
self.download_url.as_deref()
}
}
impl std::fmt::Debug for BusinessReport {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("BusinessReport");
formatter.field("status", &self.status);
formatter.field("failure_code", &self.failure_code);
formatter.field("s3_location", &self.s3_location);
formatter.field("delivery_time", &self.delivery_time);
formatter.field("download_url", &self.download_url);
formatter.finish()
}
}
pub mod business_report {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) status: std::option::Option<crate::model::BusinessReportStatus>,
pub(crate) failure_code: std::option::Option<crate::model::BusinessReportFailureCode>,
pub(crate) s3_location: std::option::Option<crate::model::BusinessReportS3Location>,
pub(crate) delivery_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) download_url: std::option::Option<std::string::String>,
}
impl Builder {
pub fn status(mut self, input: crate::model::BusinessReportStatus) -> Self {
self.status = Some(input);
self
}
pub fn set_status(
mut self,
input: std::option::Option<crate::model::BusinessReportStatus>,
) -> Self {
self.status = input;
self
}
pub fn failure_code(mut self, input: crate::model::BusinessReportFailureCode) -> Self {
self.failure_code = Some(input);
self
}
pub fn set_failure_code(
mut self,
input: std::option::Option<crate::model::BusinessReportFailureCode>,
) -> Self {
self.failure_code = input;
self
}
pub fn s3_location(mut self, input: crate::model::BusinessReportS3Location) -> Self {
self.s3_location = Some(input);
self
}
pub fn set_s3_location(
mut self,
input: std::option::Option<crate::model::BusinessReportS3Location>,
) -> Self {
self.s3_location = input;
self
}
pub fn delivery_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.delivery_time = Some(input);
self
}
pub fn set_delivery_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.delivery_time = input;
self
}
pub fn download_url(mut self, input: impl Into<std::string::String>) -> Self {
self.download_url = Some(input.into());
self
}
pub fn set_download_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.download_url = input;
self
}
pub fn build(self) -> crate::model::BusinessReport {
crate::model::BusinessReport {
status: self.status,
failure_code: self.failure_code,
s3_location: self.s3_location,
delivery_time: self.delivery_time,
download_url: self.download_url,
}
}
}
}
impl BusinessReport {
pub fn builder() -> crate::model::business_report::Builder {
crate::model::business_report::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BusinessReportS3Location {
pub path: std::option::Option<std::string::String>,
pub bucket_name: std::option::Option<std::string::String>,
}
impl BusinessReportS3Location {
pub fn path(&self) -> std::option::Option<&str> {
self.path.as_deref()
}
pub fn bucket_name(&self) -> std::option::Option<&str> {
self.bucket_name.as_deref()
}
}
impl std::fmt::Debug for BusinessReportS3Location {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("BusinessReportS3Location");
formatter.field("path", &self.path);
formatter.field("bucket_name", &self.bucket_name);
formatter.finish()
}
}
pub mod business_report_s3_location {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) path: std::option::Option<std::string::String>,
pub(crate) bucket_name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn path(mut self, input: impl Into<std::string::String>) -> Self {
self.path = Some(input.into());
self
}
pub fn set_path(mut self, input: std::option::Option<std::string::String>) -> Self {
self.path = input;
self
}
pub fn bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
self.bucket_name = Some(input.into());
self
}
pub fn set_bucket_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.bucket_name = input;
self
}
pub fn build(self) -> crate::model::BusinessReportS3Location {
crate::model::BusinessReportS3Location {
path: self.path,
bucket_name: self.bucket_name,
}
}
}
}
impl BusinessReportS3Location {
pub fn builder() -> crate::model::business_report_s3_location::Builder {
crate::model::business_report_s3_location::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum BusinessReportFailureCode {
#[allow(missing_docs)] AccessDenied,
#[allow(missing_docs)] InternalFailure,
#[allow(missing_docs)] NoSuchBucket,
Unknown(String),
}
impl std::convert::From<&str> for BusinessReportFailureCode {
fn from(s: &str) -> Self {
match s {
"ACCESS_DENIED" => BusinessReportFailureCode::AccessDenied,
"INTERNAL_FAILURE" => BusinessReportFailureCode::InternalFailure,
"NO_SUCH_BUCKET" => BusinessReportFailureCode::NoSuchBucket,
other => BusinessReportFailureCode::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for BusinessReportFailureCode {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(BusinessReportFailureCode::from(s))
}
}
impl BusinessReportFailureCode {
pub fn as_str(&self) -> &str {
match self {
BusinessReportFailureCode::AccessDenied => "ACCESS_DENIED",
BusinessReportFailureCode::InternalFailure => "INTERNAL_FAILURE",
BusinessReportFailureCode::NoSuchBucket => "NO_SUCH_BUCKET",
BusinessReportFailureCode::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ACCESS_DENIED", "INTERNAL_FAILURE", "NO_SUCH_BUCKET"]
}
}
impl AsRef<str> for BusinessReportFailureCode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum BusinessReportStatus {
#[allow(missing_docs)] Failed,
#[allow(missing_docs)] Running,
#[allow(missing_docs)] Succeeded,
Unknown(String),
}
impl std::convert::From<&str> for BusinessReportStatus {
fn from(s: &str) -> Self {
match s {
"FAILED" => BusinessReportStatus::Failed,
"RUNNING" => BusinessReportStatus::Running,
"SUCCEEDED" => BusinessReportStatus::Succeeded,
other => BusinessReportStatus::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for BusinessReportStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(BusinessReportStatus::from(s))
}
}
impl BusinessReportStatus {
pub fn as_str(&self) -> &str {
match self {
BusinessReportStatus::Failed => "FAILED",
BusinessReportStatus::Running => "RUNNING",
BusinessReportStatus::Succeeded => "SUCCEEDED",
BusinessReportStatus::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["FAILED", "RUNNING", "SUCCEEDED"]
}
}
impl AsRef<str> for BusinessReportStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BusinessReportContentRange {
pub interval: std::option::Option<crate::model::BusinessReportInterval>,
}
impl BusinessReportContentRange {
pub fn interval(&self) -> std::option::Option<&crate::model::BusinessReportInterval> {
self.interval.as_ref()
}
}
impl std::fmt::Debug for BusinessReportContentRange {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("BusinessReportContentRange");
formatter.field("interval", &self.interval);
formatter.finish()
}
}
pub mod business_report_content_range {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) interval: std::option::Option<crate::model::BusinessReportInterval>,
}
impl Builder {
pub fn interval(mut self, input: crate::model::BusinessReportInterval) -> Self {
self.interval = Some(input);
self
}
pub fn set_interval(
mut self,
input: std::option::Option<crate::model::BusinessReportInterval>,
) -> Self {
self.interval = input;
self
}
pub fn build(self) -> crate::model::BusinessReportContentRange {
crate::model::BusinessReportContentRange {
interval: self.interval,
}
}
}
}
impl BusinessReportContentRange {
pub fn builder() -> crate::model::business_report_content_range::Builder {
crate::model::business_report_content_range::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum BusinessReportInterval {
#[allow(missing_docs)] OneDay,
#[allow(missing_docs)] OneWeek,
#[allow(missing_docs)] ThirtyDays,
Unknown(String),
}
impl std::convert::From<&str> for BusinessReportInterval {
fn from(s: &str) -> Self {
match s {
"ONE_DAY" => BusinessReportInterval::OneDay,
"ONE_WEEK" => BusinessReportInterval::OneWeek,
"THIRTY_DAYS" => BusinessReportInterval::ThirtyDays,
other => BusinessReportInterval::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for BusinessReportInterval {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(BusinessReportInterval::from(s))
}
}
impl BusinessReportInterval {
pub fn as_str(&self) -> &str {
match self {
BusinessReportInterval::OneDay => "ONE_DAY",
BusinessReportInterval::OneWeek => "ONE_WEEK",
BusinessReportInterval::ThirtyDays => "THIRTY_DAYS",
BusinessReportInterval::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["ONE_DAY", "ONE_WEEK", "THIRTY_DAYS"]
}
}
impl AsRef<str> for BusinessReportInterval {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SkillGroup {
pub skill_group_arn: std::option::Option<std::string::String>,
pub skill_group_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl SkillGroup {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn skill_group_name(&self) -> std::option::Option<&str> {
self.skill_group_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for SkillGroup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SkillGroup");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("skill_group_name", &self.skill_group_name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod skill_group {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) skill_group_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn skill_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_name = Some(input.into());
self
}
pub fn set_skill_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::SkillGroup {
crate::model::SkillGroup {
skill_group_arn: self.skill_group_arn,
skill_group_name: self.skill_group_name,
description: self.description,
}
}
}
}
impl SkillGroup {
pub fn builder() -> crate::model::skill_group::Builder {
crate::model::skill_group::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Room {
pub room_arn: std::option::Option<std::string::String>,
pub room_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub provider_calendar_id: std::option::Option<std::string::String>,
pub profile_arn: std::option::Option<std::string::String>,
}
impl Room {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn room_name(&self) -> std::option::Option<&str> {
self.room_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn provider_calendar_id(&self) -> std::option::Option<&str> {
self.provider_calendar_id.as_deref()
}
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
}
impl std::fmt::Debug for Room {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Room");
formatter.field("room_arn", &self.room_arn);
formatter.field("room_name", &self.room_name);
formatter.field("description", &self.description);
formatter.field("provider_calendar_id", &self.provider_calendar_id);
formatter.field("profile_arn", &self.profile_arn);
formatter.finish()
}
}
pub mod room {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) room_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) provider_calendar_id: std::option::Option<std::string::String>,
pub(crate) profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn room_name(mut self, input: impl Into<std::string::String>) -> Self {
self.room_name = Some(input.into());
self
}
pub fn set_room_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn provider_calendar_id(mut self, input: impl Into<std::string::String>) -> Self {
self.provider_calendar_id = Some(input.into());
self
}
pub fn set_provider_calendar_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.provider_calendar_id = input;
self
}
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn build(self) -> crate::model::Room {
crate::model::Room {
room_arn: self.room_arn,
room_name: self.room_name,
description: self.description,
provider_calendar_id: self.provider_calendar_id,
profile_arn: self.profile_arn,
}
}
}
}
impl Room {
pub fn builder() -> crate::model::room::Builder {
crate::model::room::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Profile {
pub profile_arn: std::option::Option<std::string::String>,
pub profile_name: std::option::Option<std::string::String>,
pub is_default: std::option::Option<bool>,
pub address: std::option::Option<std::string::String>,
pub timezone: std::option::Option<std::string::String>,
pub distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub wake_word: std::option::Option<crate::model::WakeWord>,
pub locale: std::option::Option<std::string::String>,
pub setup_mode_disabled: std::option::Option<bool>,
pub max_volume_limit: std::option::Option<i32>,
pub pstn_enabled: std::option::Option<bool>,
pub data_retention_opt_in: std::option::Option<bool>,
pub address_book_arn: std::option::Option<std::string::String>,
pub meeting_room_configuration: std::option::Option<crate::model::MeetingRoomConfiguration>,
}
impl Profile {
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
pub fn profile_name(&self) -> std::option::Option<&str> {
self.profile_name.as_deref()
}
pub fn is_default(&self) -> std::option::Option<bool> {
self.is_default
}
pub fn address(&self) -> std::option::Option<&str> {
self.address.as_deref()
}
pub fn timezone(&self) -> std::option::Option<&str> {
self.timezone.as_deref()
}
pub fn distance_unit(&self) -> std::option::Option<&crate::model::DistanceUnit> {
self.distance_unit.as_ref()
}
pub fn temperature_unit(&self) -> std::option::Option<&crate::model::TemperatureUnit> {
self.temperature_unit.as_ref()
}
pub fn wake_word(&self) -> std::option::Option<&crate::model::WakeWord> {
self.wake_word.as_ref()
}
pub fn locale(&self) -> std::option::Option<&str> {
self.locale.as_deref()
}
pub fn setup_mode_disabled(&self) -> std::option::Option<bool> {
self.setup_mode_disabled
}
pub fn max_volume_limit(&self) -> std::option::Option<i32> {
self.max_volume_limit
}
pub fn pstn_enabled(&self) -> std::option::Option<bool> {
self.pstn_enabled
}
pub fn data_retention_opt_in(&self) -> std::option::Option<bool> {
self.data_retention_opt_in
}
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
pub fn meeting_room_configuration(
&self,
) -> std::option::Option<&crate::model::MeetingRoomConfiguration> {
self.meeting_room_configuration.as_ref()
}
}
impl std::fmt::Debug for Profile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Profile");
formatter.field("profile_arn", &self.profile_arn);
formatter.field("profile_name", &self.profile_name);
formatter.field("is_default", &self.is_default);
formatter.field("address", &self.address);
formatter.field("timezone", &self.timezone);
formatter.field("distance_unit", &self.distance_unit);
formatter.field("temperature_unit", &self.temperature_unit);
formatter.field("wake_word", &self.wake_word);
formatter.field("locale", &self.locale);
formatter.field("setup_mode_disabled", &self.setup_mode_disabled);
formatter.field("max_volume_limit", &self.max_volume_limit);
formatter.field("pstn_enabled", &self.pstn_enabled);
formatter.field("data_retention_opt_in", &self.data_retention_opt_in);
formatter.field("address_book_arn", &self.address_book_arn);
formatter.field(
"meeting_room_configuration",
&self.meeting_room_configuration,
);
formatter.finish()
}
}
pub mod profile {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_arn: std::option::Option<std::string::String>,
pub(crate) profile_name: std::option::Option<std::string::String>,
pub(crate) is_default: std::option::Option<bool>,
pub(crate) address: std::option::Option<std::string::String>,
pub(crate) timezone: std::option::Option<std::string::String>,
pub(crate) distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub(crate) temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub(crate) wake_word: std::option::Option<crate::model::WakeWord>,
pub(crate) locale: std::option::Option<std::string::String>,
pub(crate) setup_mode_disabled: std::option::Option<bool>,
pub(crate) max_volume_limit: std::option::Option<i32>,
pub(crate) pstn_enabled: std::option::Option<bool>,
pub(crate) data_retention_opt_in: std::option::Option<bool>,
pub(crate) address_book_arn: std::option::Option<std::string::String>,
pub(crate) meeting_room_configuration:
std::option::Option<crate::model::MeetingRoomConfiguration>,
}
impl Builder {
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_name = Some(input.into());
self
}
pub fn set_profile_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_name = input;
self
}
pub fn is_default(mut self, input: bool) -> Self {
self.is_default = Some(input);
self
}
pub fn set_is_default(mut self, input: std::option::Option<bool>) -> Self {
self.is_default = input;
self
}
pub fn address(mut self, input: impl Into<std::string::String>) -> Self {
self.address = Some(input.into());
self
}
pub fn set_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.address = input;
self
}
pub fn timezone(mut self, input: impl Into<std::string::String>) -> Self {
self.timezone = Some(input.into());
self
}
pub fn set_timezone(mut self, input: std::option::Option<std::string::String>) -> Self {
self.timezone = input;
self
}
pub fn distance_unit(mut self, input: crate::model::DistanceUnit) -> Self {
self.distance_unit = Some(input);
self
}
pub fn set_distance_unit(
mut self,
input: std::option::Option<crate::model::DistanceUnit>,
) -> Self {
self.distance_unit = input;
self
}
pub fn temperature_unit(mut self, input: crate::model::TemperatureUnit) -> Self {
self.temperature_unit = Some(input);
self
}
pub fn set_temperature_unit(
mut self,
input: std::option::Option<crate::model::TemperatureUnit>,
) -> Self {
self.temperature_unit = input;
self
}
pub fn wake_word(mut self, input: crate::model::WakeWord) -> Self {
self.wake_word = Some(input);
self
}
pub fn set_wake_word(mut self, input: std::option::Option<crate::model::WakeWord>) -> Self {
self.wake_word = input;
self
}
pub fn locale(mut self, input: impl Into<std::string::String>) -> Self {
self.locale = Some(input.into());
self
}
pub fn set_locale(mut self, input: std::option::Option<std::string::String>) -> Self {
self.locale = input;
self
}
pub fn setup_mode_disabled(mut self, input: bool) -> Self {
self.setup_mode_disabled = Some(input);
self
}
pub fn set_setup_mode_disabled(mut self, input: std::option::Option<bool>) -> Self {
self.setup_mode_disabled = input;
self
}
pub fn max_volume_limit(mut self, input: i32) -> Self {
self.max_volume_limit = Some(input);
self
}
pub fn set_max_volume_limit(mut self, input: std::option::Option<i32>) -> Self {
self.max_volume_limit = input;
self
}
pub fn pstn_enabled(mut self, input: bool) -> Self {
self.pstn_enabled = Some(input);
self
}
pub fn set_pstn_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.pstn_enabled = input;
self
}
pub fn data_retention_opt_in(mut self, input: bool) -> Self {
self.data_retention_opt_in = Some(input);
self
}
pub fn set_data_retention_opt_in(mut self, input: std::option::Option<bool>) -> Self {
self.data_retention_opt_in = input;
self
}
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn meeting_room_configuration(
mut self,
input: crate::model::MeetingRoomConfiguration,
) -> Self {
self.meeting_room_configuration = Some(input);
self
}
pub fn set_meeting_room_configuration(
mut self,
input: std::option::Option<crate::model::MeetingRoomConfiguration>,
) -> Self {
self.meeting_room_configuration = input;
self
}
pub fn build(self) -> crate::model::Profile {
crate::model::Profile {
profile_arn: self.profile_arn,
profile_name: self.profile_name,
is_default: self.is_default,
address: self.address,
timezone: self.timezone,
distance_unit: self.distance_unit,
temperature_unit: self.temperature_unit,
wake_word: self.wake_word,
locale: self.locale,
setup_mode_disabled: self.setup_mode_disabled,
max_volume_limit: self.max_volume_limit,
pstn_enabled: self.pstn_enabled,
data_retention_opt_in: self.data_retention_opt_in,
address_book_arn: self.address_book_arn,
meeting_room_configuration: self.meeting_room_configuration,
}
}
}
}
impl Profile {
pub fn builder() -> crate::model::profile::Builder {
crate::model::profile::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct MeetingRoomConfiguration {
pub room_utilization_metrics_enabled: std::option::Option<bool>,
pub end_of_meeting_reminder: std::option::Option<crate::model::EndOfMeetingReminder>,
pub instant_booking: std::option::Option<crate::model::InstantBooking>,
pub require_check_in: std::option::Option<crate::model::RequireCheckIn>,
}
impl MeetingRoomConfiguration {
pub fn room_utilization_metrics_enabled(&self) -> std::option::Option<bool> {
self.room_utilization_metrics_enabled
}
pub fn end_of_meeting_reminder(
&self,
) -> std::option::Option<&crate::model::EndOfMeetingReminder> {
self.end_of_meeting_reminder.as_ref()
}
pub fn instant_booking(&self) -> std::option::Option<&crate::model::InstantBooking> {
self.instant_booking.as_ref()
}
pub fn require_check_in(&self) -> std::option::Option<&crate::model::RequireCheckIn> {
self.require_check_in.as_ref()
}
}
impl std::fmt::Debug for MeetingRoomConfiguration {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("MeetingRoomConfiguration");
formatter.field(
"room_utilization_metrics_enabled",
&self.room_utilization_metrics_enabled,
);
formatter.field("end_of_meeting_reminder", &self.end_of_meeting_reminder);
formatter.field("instant_booking", &self.instant_booking);
formatter.field("require_check_in", &self.require_check_in);
formatter.finish()
}
}
pub mod meeting_room_configuration {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_utilization_metrics_enabled: std::option::Option<bool>,
pub(crate) end_of_meeting_reminder: std::option::Option<crate::model::EndOfMeetingReminder>,
pub(crate) instant_booking: std::option::Option<crate::model::InstantBooking>,
pub(crate) require_check_in: std::option::Option<crate::model::RequireCheckIn>,
}
impl Builder {
pub fn room_utilization_metrics_enabled(mut self, input: bool) -> Self {
self.room_utilization_metrics_enabled = Some(input);
self
}
pub fn set_room_utilization_metrics_enabled(
mut self,
input: std::option::Option<bool>,
) -> Self {
self.room_utilization_metrics_enabled = input;
self
}
pub fn end_of_meeting_reminder(
mut self,
input: crate::model::EndOfMeetingReminder,
) -> Self {
self.end_of_meeting_reminder = Some(input);
self
}
pub fn set_end_of_meeting_reminder(
mut self,
input: std::option::Option<crate::model::EndOfMeetingReminder>,
) -> Self {
self.end_of_meeting_reminder = input;
self
}
pub fn instant_booking(mut self, input: crate::model::InstantBooking) -> Self {
self.instant_booking = Some(input);
self
}
pub fn set_instant_booking(
mut self,
input: std::option::Option<crate::model::InstantBooking>,
) -> Self {
self.instant_booking = input;
self
}
pub fn require_check_in(mut self, input: crate::model::RequireCheckIn) -> Self {
self.require_check_in = Some(input);
self
}
pub fn set_require_check_in(
mut self,
input: std::option::Option<crate::model::RequireCheckIn>,
) -> Self {
self.require_check_in = input;
self
}
pub fn build(self) -> crate::model::MeetingRoomConfiguration {
crate::model::MeetingRoomConfiguration {
room_utilization_metrics_enabled: self.room_utilization_metrics_enabled,
end_of_meeting_reminder: self.end_of_meeting_reminder,
instant_booking: self.instant_booking,
require_check_in: self.require_check_in,
}
}
}
}
impl MeetingRoomConfiguration {
pub fn builder() -> crate::model::meeting_room_configuration::Builder {
crate::model::meeting_room_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RequireCheckIn {
pub release_after_minutes: std::option::Option<i32>,
pub enabled: std::option::Option<bool>,
}
impl RequireCheckIn {
pub fn release_after_minutes(&self) -> std::option::Option<i32> {
self.release_after_minutes
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for RequireCheckIn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RequireCheckIn");
formatter.field("release_after_minutes", &self.release_after_minutes);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod require_check_in {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) release_after_minutes: std::option::Option<i32>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn release_after_minutes(mut self, input: i32) -> Self {
self.release_after_minutes = Some(input);
self
}
pub fn set_release_after_minutes(mut self, input: std::option::Option<i32>) -> Self {
self.release_after_minutes = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::RequireCheckIn {
crate::model::RequireCheckIn {
release_after_minutes: self.release_after_minutes,
enabled: self.enabled,
}
}
}
}
impl RequireCheckIn {
pub fn builder() -> crate::model::require_check_in::Builder {
crate::model::require_check_in::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct InstantBooking {
pub duration_in_minutes: std::option::Option<i32>,
pub enabled: std::option::Option<bool>,
}
impl InstantBooking {
pub fn duration_in_minutes(&self) -> std::option::Option<i32> {
self.duration_in_minutes
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for InstantBooking {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("InstantBooking");
formatter.field("duration_in_minutes", &self.duration_in_minutes);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod instant_booking {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) duration_in_minutes: std::option::Option<i32>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn duration_in_minutes(mut self, input: i32) -> Self {
self.duration_in_minutes = Some(input);
self
}
pub fn set_duration_in_minutes(mut self, input: std::option::Option<i32>) -> Self {
self.duration_in_minutes = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::InstantBooking {
crate::model::InstantBooking {
duration_in_minutes: self.duration_in_minutes,
enabled: self.enabled,
}
}
}
}
impl InstantBooking {
pub fn builder() -> crate::model::instant_booking::Builder {
crate::model::instant_booking::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct EndOfMeetingReminder {
pub reminder_at_minutes: std::option::Option<std::vec::Vec<i32>>,
pub reminder_type: std::option::Option<crate::model::EndOfMeetingReminderType>,
pub enabled: std::option::Option<bool>,
}
impl EndOfMeetingReminder {
pub fn reminder_at_minutes(&self) -> std::option::Option<&[i32]> {
self.reminder_at_minutes.as_deref()
}
pub fn reminder_type(&self) -> std::option::Option<&crate::model::EndOfMeetingReminderType> {
self.reminder_type.as_ref()
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for EndOfMeetingReminder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("EndOfMeetingReminder");
formatter.field("reminder_at_minutes", &self.reminder_at_minutes);
formatter.field("reminder_type", &self.reminder_type);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod end_of_meeting_reminder {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) reminder_at_minutes: std::option::Option<std::vec::Vec<i32>>,
pub(crate) reminder_type: std::option::Option<crate::model::EndOfMeetingReminderType>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn reminder_at_minutes(mut self, input: impl Into<i32>) -> Self {
let mut v = self.reminder_at_minutes.unwrap_or_default();
v.push(input.into());
self.reminder_at_minutes = Some(v);
self
}
pub fn set_reminder_at_minutes(
mut self,
input: std::option::Option<std::vec::Vec<i32>>,
) -> Self {
self.reminder_at_minutes = input;
self
}
pub fn reminder_type(mut self, input: crate::model::EndOfMeetingReminderType) -> Self {
self.reminder_type = Some(input);
self
}
pub fn set_reminder_type(
mut self,
input: std::option::Option<crate::model::EndOfMeetingReminderType>,
) -> Self {
self.reminder_type = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::EndOfMeetingReminder {
crate::model::EndOfMeetingReminder {
reminder_at_minutes: self.reminder_at_minutes,
reminder_type: self.reminder_type,
enabled: self.enabled,
}
}
}
}
impl EndOfMeetingReminder {
pub fn builder() -> crate::model::end_of_meeting_reminder::Builder {
crate::model::end_of_meeting_reminder::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct NetworkProfile {
pub network_profile_arn: std::option::Option<std::string::String>,
pub network_profile_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub ssid: std::option::Option<std::string::String>,
pub security_type: std::option::Option<crate::model::NetworkSecurityType>,
pub eap_method: std::option::Option<crate::model::NetworkEapMethod>,
pub current_password: std::option::Option<std::string::String>,
pub next_password: std::option::Option<std::string::String>,
pub certificate_authority_arn: std::option::Option<std::string::String>,
pub trust_anchors: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl NetworkProfile {
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
pub fn network_profile_name(&self) -> std::option::Option<&str> {
self.network_profile_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn ssid(&self) -> std::option::Option<&str> {
self.ssid.as_deref()
}
pub fn security_type(&self) -> std::option::Option<&crate::model::NetworkSecurityType> {
self.security_type.as_ref()
}
pub fn eap_method(&self) -> std::option::Option<&crate::model::NetworkEapMethod> {
self.eap_method.as_ref()
}
pub fn current_password(&self) -> std::option::Option<&str> {
self.current_password.as_deref()
}
pub fn next_password(&self) -> std::option::Option<&str> {
self.next_password.as_deref()
}
pub fn certificate_authority_arn(&self) -> std::option::Option<&str> {
self.certificate_authority_arn.as_deref()
}
pub fn trust_anchors(&self) -> std::option::Option<&[std::string::String]> {
self.trust_anchors.as_deref()
}
}
impl std::fmt::Debug for NetworkProfile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("NetworkProfile");
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.field("network_profile_name", &self.network_profile_name);
formatter.field("description", &self.description);
formatter.field("ssid", &self.ssid);
formatter.field("security_type", &self.security_type);
formatter.field("eap_method", &self.eap_method);
formatter.field("current_password", &"*** Sensitive Data Redacted ***");
formatter.field("next_password", &"*** Sensitive Data Redacted ***");
formatter.field("certificate_authority_arn", &self.certificate_authority_arn);
formatter.field("trust_anchors", &self.trust_anchors);
formatter.finish()
}
}
pub mod network_profile {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
pub(crate) network_profile_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) ssid: std::option::Option<std::string::String>,
pub(crate) security_type: std::option::Option<crate::model::NetworkSecurityType>,
pub(crate) eap_method: std::option::Option<crate::model::NetworkEapMethod>,
pub(crate) current_password: std::option::Option<std::string::String>,
pub(crate) next_password: std::option::Option<std::string::String>,
pub(crate) certificate_authority_arn: std::option::Option<std::string::String>,
pub(crate) trust_anchors: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn network_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_name = Some(input.into());
self
}
pub fn set_network_profile_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn ssid(mut self, input: impl Into<std::string::String>) -> Self {
self.ssid = Some(input.into());
self
}
pub fn set_ssid(mut self, input: std::option::Option<std::string::String>) -> Self {
self.ssid = input;
self
}
pub fn security_type(mut self, input: crate::model::NetworkSecurityType) -> Self {
self.security_type = Some(input);
self
}
pub fn set_security_type(
mut self,
input: std::option::Option<crate::model::NetworkSecurityType>,
) -> Self {
self.security_type = input;
self
}
pub fn eap_method(mut self, input: crate::model::NetworkEapMethod) -> Self {
self.eap_method = Some(input);
self
}
pub fn set_eap_method(
mut self,
input: std::option::Option<crate::model::NetworkEapMethod>,
) -> Self {
self.eap_method = input;
self
}
pub fn current_password(mut self, input: impl Into<std::string::String>) -> Self {
self.current_password = Some(input.into());
self
}
pub fn set_current_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.current_password = input;
self
}
pub fn next_password(mut self, input: impl Into<std::string::String>) -> Self {
self.next_password = Some(input.into());
self
}
pub fn set_next_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.next_password = input;
self
}
pub fn certificate_authority_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_authority_arn = Some(input.into());
self
}
pub fn set_certificate_authority_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_authority_arn = input;
self
}
pub fn trust_anchors(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.trust_anchors.unwrap_or_default();
v.push(input.into());
self.trust_anchors = Some(v);
self
}
pub fn set_trust_anchors(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.trust_anchors = input;
self
}
pub fn build(self) -> crate::model::NetworkProfile {
crate::model::NetworkProfile {
network_profile_arn: self.network_profile_arn,
network_profile_name: self.network_profile_name,
description: self.description,
ssid: self.ssid,
security_type: self.security_type,
eap_method: self.eap_method,
current_password: self.current_password,
next_password: self.next_password,
certificate_authority_arn: self.certificate_authority_arn,
trust_anchors: self.trust_anchors,
}
}
}
}
impl NetworkProfile {
pub fn builder() -> crate::model::network_profile::Builder {
crate::model::network_profile::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GatewayGroup {
pub arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl GatewayGroup {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for GatewayGroup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GatewayGroup");
formatter.field("arn", &self.arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod gateway_group {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::GatewayGroup {
crate::model::GatewayGroup {
arn: self.arn,
name: self.name,
description: self.description,
}
}
}
}
impl GatewayGroup {
pub fn builder() -> crate::model::gateway_group::Builder {
crate::model::gateway_group::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Gateway {
pub arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub gateway_group_arn: std::option::Option<std::string::String>,
pub software_version: std::option::Option<std::string::String>,
}
impl Gateway {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn gateway_group_arn(&self) -> std::option::Option<&str> {
self.gateway_group_arn.as_deref()
}
pub fn software_version(&self) -> std::option::Option<&str> {
self.software_version.as_deref()
}
}
impl std::fmt::Debug for Gateway {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Gateway");
formatter.field("arn", &self.arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("gateway_group_arn", &self.gateway_group_arn);
formatter.field("software_version", &self.software_version);
formatter.finish()
}
}
pub mod gateway {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) gateway_group_arn: std::option::Option<std::string::String>,
pub(crate) software_version: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn gateway_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_group_arn = Some(input.into());
self
}
pub fn set_gateway_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.gateway_group_arn = input;
self
}
pub fn software_version(mut self, input: impl Into<std::string::String>) -> Self {
self.software_version = Some(input.into());
self
}
pub fn set_software_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.software_version = input;
self
}
pub fn build(self) -> crate::model::Gateway {
crate::model::Gateway {
arn: self.arn,
name: self.name,
description: self.description,
gateway_group_arn: self.gateway_group_arn,
software_version: self.software_version,
}
}
}
}
impl Gateway {
pub fn builder() -> crate::model::gateway::Builder {
crate::model::gateway::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Device {
pub device_arn: std::option::Option<std::string::String>,
pub device_serial_number: std::option::Option<std::string::String>,
pub device_type: std::option::Option<std::string::String>,
pub device_name: std::option::Option<std::string::String>,
pub software_version: std::option::Option<std::string::String>,
pub mac_address: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
pub device_status: std::option::Option<crate::model::DeviceStatus>,
pub device_status_info: std::option::Option<crate::model::DeviceStatusInfo>,
pub network_profile_info: std::option::Option<crate::model::DeviceNetworkProfileInfo>,
}
impl Device {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn device_serial_number(&self) -> std::option::Option<&str> {
self.device_serial_number.as_deref()
}
pub fn device_type(&self) -> std::option::Option<&str> {
self.device_type.as_deref()
}
pub fn device_name(&self) -> std::option::Option<&str> {
self.device_name.as_deref()
}
pub fn software_version(&self) -> std::option::Option<&str> {
self.software_version.as_deref()
}
pub fn mac_address(&self) -> std::option::Option<&str> {
self.mac_address.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn device_status(&self) -> std::option::Option<&crate::model::DeviceStatus> {
self.device_status.as_ref()
}
pub fn device_status_info(&self) -> std::option::Option<&crate::model::DeviceStatusInfo> {
self.device_status_info.as_ref()
}
pub fn network_profile_info(
&self,
) -> std::option::Option<&crate::model::DeviceNetworkProfileInfo> {
self.network_profile_info.as_ref()
}
}
impl std::fmt::Debug for Device {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Device");
formatter.field("device_arn", &self.device_arn);
formatter.field("device_serial_number", &self.device_serial_number);
formatter.field("device_type", &self.device_type);
formatter.field("device_name", &self.device_name);
formatter.field("software_version", &self.software_version);
formatter.field("mac_address", &self.mac_address);
formatter.field("room_arn", &self.room_arn);
formatter.field("device_status", &self.device_status);
formatter.field("device_status_info", &self.device_status_info);
formatter.field("network_profile_info", &self.network_profile_info);
formatter.finish()
}
}
pub mod device {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) device_serial_number: std::option::Option<std::string::String>,
pub(crate) device_type: std::option::Option<std::string::String>,
pub(crate) device_name: std::option::Option<std::string::String>,
pub(crate) software_version: std::option::Option<std::string::String>,
pub(crate) mac_address: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) device_status: std::option::Option<crate::model::DeviceStatus>,
pub(crate) device_status_info: std::option::Option<crate::model::DeviceStatusInfo>,
pub(crate) network_profile_info:
std::option::Option<crate::model::DeviceNetworkProfileInfo>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn device_serial_number(mut self, input: impl Into<std::string::String>) -> Self {
self.device_serial_number = Some(input.into());
self
}
pub fn set_device_serial_number(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.device_serial_number = input;
self
}
pub fn device_type(mut self, input: impl Into<std::string::String>) -> Self {
self.device_type = Some(input.into());
self
}
pub fn set_device_type(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_type = input;
self
}
pub fn device_name(mut self, input: impl Into<std::string::String>) -> Self {
self.device_name = Some(input.into());
self
}
pub fn set_device_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_name = input;
self
}
pub fn software_version(mut self, input: impl Into<std::string::String>) -> Self {
self.software_version = Some(input.into());
self
}
pub fn set_software_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.software_version = input;
self
}
pub fn mac_address(mut self, input: impl Into<std::string::String>) -> Self {
self.mac_address = Some(input.into());
self
}
pub fn set_mac_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.mac_address = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn device_status(mut self, input: crate::model::DeviceStatus) -> Self {
self.device_status = Some(input);
self
}
pub fn set_device_status(
mut self,
input: std::option::Option<crate::model::DeviceStatus>,
) -> Self {
self.device_status = input;
self
}
pub fn device_status_info(mut self, input: crate::model::DeviceStatusInfo) -> Self {
self.device_status_info = Some(input);
self
}
pub fn set_device_status_info(
mut self,
input: std::option::Option<crate::model::DeviceStatusInfo>,
) -> Self {
self.device_status_info = input;
self
}
pub fn network_profile_info(
mut self,
input: crate::model::DeviceNetworkProfileInfo,
) -> Self {
self.network_profile_info = Some(input);
self
}
pub fn set_network_profile_info(
mut self,
input: std::option::Option<crate::model::DeviceNetworkProfileInfo>,
) -> Self {
self.network_profile_info = input;
self
}
pub fn build(self) -> crate::model::Device {
crate::model::Device {
device_arn: self.device_arn,
device_serial_number: self.device_serial_number,
device_type: self.device_type,
device_name: self.device_name,
software_version: self.software_version,
mac_address: self.mac_address,
room_arn: self.room_arn,
device_status: self.device_status,
device_status_info: self.device_status_info,
network_profile_info: self.network_profile_info,
}
}
}
}
impl Device {
pub fn builder() -> crate::model::device::Builder {
crate::model::device::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeviceNetworkProfileInfo {
pub network_profile_arn: std::option::Option<std::string::String>,
pub certificate_arn: std::option::Option<std::string::String>,
pub certificate_expiration_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl DeviceNetworkProfileInfo {
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
pub fn certificate_arn(&self) -> std::option::Option<&str> {
self.certificate_arn.as_deref()
}
pub fn certificate_expiration_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.certificate_expiration_time.as_ref()
}
}
impl std::fmt::Debug for DeviceNetworkProfileInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeviceNetworkProfileInfo");
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.field("certificate_arn", &self.certificate_arn);
formatter.field(
"certificate_expiration_time",
&self.certificate_expiration_time,
);
formatter.finish()
}
}
pub mod device_network_profile_info {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
pub(crate) certificate_arn: std::option::Option<std::string::String>,
pub(crate) certificate_expiration_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn certificate_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_arn = Some(input.into());
self
}
pub fn set_certificate_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_arn = input;
self
}
pub fn certificate_expiration_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.certificate_expiration_time = Some(input);
self
}
pub fn set_certificate_expiration_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.certificate_expiration_time = input;
self
}
pub fn build(self) -> crate::model::DeviceNetworkProfileInfo {
crate::model::DeviceNetworkProfileInfo {
network_profile_arn: self.network_profile_arn,
certificate_arn: self.certificate_arn,
certificate_expiration_time: self.certificate_expiration_time,
}
}
}
}
impl DeviceNetworkProfileInfo {
pub fn builder() -> crate::model::device_network_profile_info::Builder {
crate::model::device_network_profile_info::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Contact {
pub contact_arn: std::option::Option<std::string::String>,
pub display_name: std::option::Option<std::string::String>,
pub first_name: std::option::Option<std::string::String>,
pub last_name: std::option::Option<std::string::String>,
pub phone_number: std::option::Option<std::string::String>,
pub phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
}
impl Contact {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
pub fn display_name(&self) -> std::option::Option<&str> {
self.display_name.as_deref()
}
pub fn first_name(&self) -> std::option::Option<&str> {
self.first_name.as_deref()
}
pub fn last_name(&self) -> std::option::Option<&str> {
self.last_name.as_deref()
}
pub fn phone_number(&self) -> std::option::Option<&str> {
self.phone_number.as_deref()
}
pub fn phone_numbers(&self) -> std::option::Option<&[crate::model::PhoneNumber]> {
self.phone_numbers.as_deref()
}
pub fn sip_addresses(&self) -> std::option::Option<&[crate::model::SipAddress]> {
self.sip_addresses.as_deref()
}
}
impl std::fmt::Debug for Contact {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Contact");
formatter.field("contact_arn", &self.contact_arn);
formatter.field("display_name", &self.display_name);
formatter.field("first_name", &self.first_name);
formatter.field("last_name", &self.last_name);
formatter.field("phone_number", &"*** Sensitive Data Redacted ***");
formatter.field("phone_numbers", &self.phone_numbers);
formatter.field("sip_addresses", &self.sip_addresses);
formatter.finish()
}
}
pub mod contact {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
pub(crate) display_name: std::option::Option<std::string::String>,
pub(crate) first_name: std::option::Option<std::string::String>,
pub(crate) last_name: std::option::Option<std::string::String>,
pub(crate) phone_number: std::option::Option<std::string::String>,
pub(crate) phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub(crate) sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
self.display_name = Some(input.into());
self
}
pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.display_name = input;
self
}
pub fn first_name(mut self, input: impl Into<std::string::String>) -> Self {
self.first_name = Some(input.into());
self
}
pub fn set_first_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.first_name = input;
self
}
pub fn last_name(mut self, input: impl Into<std::string::String>) -> Self {
self.last_name = Some(input.into());
self
}
pub fn set_last_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.last_name = input;
self
}
pub fn phone_number(mut self, input: impl Into<std::string::String>) -> Self {
self.phone_number = Some(input.into());
self
}
pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
self.phone_number = input;
self
}
pub fn phone_numbers(mut self, input: impl Into<crate::model::PhoneNumber>) -> Self {
let mut v = self.phone_numbers.unwrap_or_default();
v.push(input.into());
self.phone_numbers = Some(v);
self
}
pub fn set_phone_numbers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
) -> Self {
self.phone_numbers = input;
self
}
pub fn sip_addresses(mut self, input: impl Into<crate::model::SipAddress>) -> Self {
let mut v = self.sip_addresses.unwrap_or_default();
v.push(input.into());
self.sip_addresses = Some(v);
self
}
pub fn set_sip_addresses(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
) -> Self {
self.sip_addresses = input;
self
}
pub fn build(self) -> crate::model::Contact {
crate::model::Contact {
contact_arn: self.contact_arn,
display_name: self.display_name,
first_name: self.first_name,
last_name: self.last_name,
phone_number: self.phone_number,
phone_numbers: self.phone_numbers,
sip_addresses: self.sip_addresses,
}
}
}
}
impl Contact {
pub fn builder() -> crate::model::contact::Builder {
crate::model::contact::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AddressBook {
pub address_book_arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl AddressBook {
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for AddressBook {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AddressBook");
formatter.field("address_book_arn", &self.address_book_arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod address_book {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) address_book_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::AddressBook {
crate::model::AddressBook {
address_book_arn: self.address_book_arn,
name: self.name,
description: self.description,
}
}
}
}
impl AddressBook {
pub fn builder() -> crate::model::address_book::Builder {
crate::model::address_book::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DeviceUsageType {
#[allow(missing_docs)] Voice,
Unknown(String),
}
impl std::convert::From<&str> for DeviceUsageType {
fn from(s: &str) -> Self {
match s {
"VOICE" => DeviceUsageType::Voice,
other => DeviceUsageType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for DeviceUsageType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DeviceUsageType::from(s))
}
}
impl DeviceUsageType {
pub fn as_str(&self) -> &str {
match self {
DeviceUsageType::Voice => "VOICE",
DeviceUsageType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["VOICE"]
}
}
impl AsRef<str> for DeviceUsageType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateMeetingRoomConfiguration {
pub room_utilization_metrics_enabled: std::option::Option<bool>,
pub end_of_meeting_reminder: std::option::Option<crate::model::CreateEndOfMeetingReminder>,
pub instant_booking: std::option::Option<crate::model::CreateInstantBooking>,
pub require_check_in: std::option::Option<crate::model::CreateRequireCheckIn>,
}
impl CreateMeetingRoomConfiguration {
pub fn room_utilization_metrics_enabled(&self) -> std::option::Option<bool> {
self.room_utilization_metrics_enabled
}
pub fn end_of_meeting_reminder(
&self,
) -> std::option::Option<&crate::model::CreateEndOfMeetingReminder> {
self.end_of_meeting_reminder.as_ref()
}
pub fn instant_booking(&self) -> std::option::Option<&crate::model::CreateInstantBooking> {
self.instant_booking.as_ref()
}
pub fn require_check_in(&self) -> std::option::Option<&crate::model::CreateRequireCheckIn> {
self.require_check_in.as_ref()
}
}
impl std::fmt::Debug for CreateMeetingRoomConfiguration {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateMeetingRoomConfiguration");
formatter.field(
"room_utilization_metrics_enabled",
&self.room_utilization_metrics_enabled,
);
formatter.field("end_of_meeting_reminder", &self.end_of_meeting_reminder);
formatter.field("instant_booking", &self.instant_booking);
formatter.field("require_check_in", &self.require_check_in);
formatter.finish()
}
}
pub mod create_meeting_room_configuration {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_utilization_metrics_enabled: std::option::Option<bool>,
pub(crate) end_of_meeting_reminder:
std::option::Option<crate::model::CreateEndOfMeetingReminder>,
pub(crate) instant_booking: std::option::Option<crate::model::CreateInstantBooking>,
pub(crate) require_check_in: std::option::Option<crate::model::CreateRequireCheckIn>,
}
impl Builder {
pub fn room_utilization_metrics_enabled(mut self, input: bool) -> Self {
self.room_utilization_metrics_enabled = Some(input);
self
}
pub fn set_room_utilization_metrics_enabled(
mut self,
input: std::option::Option<bool>,
) -> Self {
self.room_utilization_metrics_enabled = input;
self
}
pub fn end_of_meeting_reminder(
mut self,
input: crate::model::CreateEndOfMeetingReminder,
) -> Self {
self.end_of_meeting_reminder = Some(input);
self
}
pub fn set_end_of_meeting_reminder(
mut self,
input: std::option::Option<crate::model::CreateEndOfMeetingReminder>,
) -> Self {
self.end_of_meeting_reminder = input;
self
}
pub fn instant_booking(mut self, input: crate::model::CreateInstantBooking) -> Self {
self.instant_booking = Some(input);
self
}
pub fn set_instant_booking(
mut self,
input: std::option::Option<crate::model::CreateInstantBooking>,
) -> Self {
self.instant_booking = input;
self
}
pub fn require_check_in(mut self, input: crate::model::CreateRequireCheckIn) -> Self {
self.require_check_in = Some(input);
self
}
pub fn set_require_check_in(
mut self,
input: std::option::Option<crate::model::CreateRequireCheckIn>,
) -> Self {
self.require_check_in = input;
self
}
pub fn build(self) -> crate::model::CreateMeetingRoomConfiguration {
crate::model::CreateMeetingRoomConfiguration {
room_utilization_metrics_enabled: self.room_utilization_metrics_enabled,
end_of_meeting_reminder: self.end_of_meeting_reminder,
instant_booking: self.instant_booking,
require_check_in: self.require_check_in,
}
}
}
}
impl CreateMeetingRoomConfiguration {
pub fn builder() -> crate::model::create_meeting_room_configuration::Builder {
crate::model::create_meeting_room_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateRequireCheckIn {
pub release_after_minutes: std::option::Option<i32>,
pub enabled: std::option::Option<bool>,
}
impl CreateRequireCheckIn {
pub fn release_after_minutes(&self) -> std::option::Option<i32> {
self.release_after_minutes
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for CreateRequireCheckIn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateRequireCheckIn");
formatter.field("release_after_minutes", &self.release_after_minutes);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod create_require_check_in {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) release_after_minutes: std::option::Option<i32>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn release_after_minutes(mut self, input: i32) -> Self {
self.release_after_minutes = Some(input);
self
}
pub fn set_release_after_minutes(mut self, input: std::option::Option<i32>) -> Self {
self.release_after_minutes = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::CreateRequireCheckIn {
crate::model::CreateRequireCheckIn {
release_after_minutes: self.release_after_minutes,
enabled: self.enabled,
}
}
}
}
impl CreateRequireCheckIn {
pub fn builder() -> crate::model::create_require_check_in::Builder {
crate::model::create_require_check_in::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateInstantBooking {
pub duration_in_minutes: std::option::Option<i32>,
pub enabled: std::option::Option<bool>,
}
impl CreateInstantBooking {
pub fn duration_in_minutes(&self) -> std::option::Option<i32> {
self.duration_in_minutes
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for CreateInstantBooking {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateInstantBooking");
formatter.field("duration_in_minutes", &self.duration_in_minutes);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod create_instant_booking {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) duration_in_minutes: std::option::Option<i32>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn duration_in_minutes(mut self, input: i32) -> Self {
self.duration_in_minutes = Some(input);
self
}
pub fn set_duration_in_minutes(mut self, input: std::option::Option<i32>) -> Self {
self.duration_in_minutes = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::CreateInstantBooking {
crate::model::CreateInstantBooking {
duration_in_minutes: self.duration_in_minutes,
enabled: self.enabled,
}
}
}
}
impl CreateInstantBooking {
pub fn builder() -> crate::model::create_instant_booking::Builder {
crate::model::create_instant_booking::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateEndOfMeetingReminder {
pub reminder_at_minutes: std::option::Option<std::vec::Vec<i32>>,
pub reminder_type: std::option::Option<crate::model::EndOfMeetingReminderType>,
pub enabled: std::option::Option<bool>,
}
impl CreateEndOfMeetingReminder {
pub fn reminder_at_minutes(&self) -> std::option::Option<&[i32]> {
self.reminder_at_minutes.as_deref()
}
pub fn reminder_type(&self) -> std::option::Option<&crate::model::EndOfMeetingReminderType> {
self.reminder_type.as_ref()
}
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for CreateEndOfMeetingReminder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateEndOfMeetingReminder");
formatter.field("reminder_at_minutes", &self.reminder_at_minutes);
formatter.field("reminder_type", &self.reminder_type);
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod create_end_of_meeting_reminder {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) reminder_at_minutes: std::option::Option<std::vec::Vec<i32>>,
pub(crate) reminder_type: std::option::Option<crate::model::EndOfMeetingReminderType>,
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn reminder_at_minutes(mut self, input: impl Into<i32>) -> Self {
let mut v = self.reminder_at_minutes.unwrap_or_default();
v.push(input.into());
self.reminder_at_minutes = Some(v);
self
}
pub fn set_reminder_at_minutes(
mut self,
input: std::option::Option<std::vec::Vec<i32>>,
) -> Self {
self.reminder_at_minutes = input;
self
}
pub fn reminder_type(mut self, input: crate::model::EndOfMeetingReminderType) -> Self {
self.reminder_type = Some(input);
self
}
pub fn set_reminder_type(
mut self,
input: std::option::Option<crate::model::EndOfMeetingReminderType>,
) -> Self {
self.reminder_type = input;
self
}
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::CreateEndOfMeetingReminder {
crate::model::CreateEndOfMeetingReminder {
reminder_at_minutes: self.reminder_at_minutes,
reminder_type: self.reminder_type,
enabled: self.enabled,
}
}
}
}
impl CreateEndOfMeetingReminder {
pub fn builder() -> crate::model::create_end_of_meeting_reminder::Builder {
crate::model::create_end_of_meeting_reminder::Builder::default()
}
}