#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RealtimeContactAnalysisSegment {
#[doc(hidden)]
pub transcript: std::option::Option<crate::model::Transcript>,
#[doc(hidden)]
pub categories: std::option::Option<crate::model::Categories>,
}
impl RealtimeContactAnalysisSegment {
pub fn transcript(&self) -> std::option::Option<&crate::model::Transcript> {
self.transcript.as_ref()
}
pub fn categories(&self) -> std::option::Option<&crate::model::Categories> {
self.categories.as_ref()
}
}
pub mod realtime_contact_analysis_segment {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transcript: std::option::Option<crate::model::Transcript>,
pub(crate) categories: std::option::Option<crate::model::Categories>,
}
impl Builder {
pub fn transcript(mut self, input: crate::model::Transcript) -> Self {
self.transcript = Some(input);
self
}
pub fn set_transcript(
mut self,
input: std::option::Option<crate::model::Transcript>,
) -> Self {
self.transcript = input;
self
}
pub fn categories(mut self, input: crate::model::Categories) -> Self {
self.categories = Some(input);
self
}
pub fn set_categories(
mut self,
input: std::option::Option<crate::model::Categories>,
) -> Self {
self.categories = input;
self
}
pub fn build(self) -> crate::model::RealtimeContactAnalysisSegment {
crate::model::RealtimeContactAnalysisSegment {
transcript: self.transcript,
categories: self.categories,
}
}
}
}
impl RealtimeContactAnalysisSegment {
pub fn builder() -> crate::model::realtime_contact_analysis_segment::Builder {
crate::model::realtime_contact_analysis_segment::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Categories {
#[doc(hidden)]
pub matched_categories: std::option::Option<std::vec::Vec<std::string::String>>,
#[doc(hidden)]
pub matched_details: std::option::Option<
std::collections::HashMap<std::string::String, crate::model::CategoryDetails>,
>,
}
impl Categories {
pub fn matched_categories(&self) -> std::option::Option<&[std::string::String]> {
self.matched_categories.as_deref()
}
pub fn matched_details(
&self,
) -> std::option::Option<
&std::collections::HashMap<std::string::String, crate::model::CategoryDetails>,
> {
self.matched_details.as_ref()
}
}
pub mod categories {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) matched_categories: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) matched_details: std::option::Option<
std::collections::HashMap<std::string::String, crate::model::CategoryDetails>,
>,
}
impl Builder {
pub fn matched_categories(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.matched_categories.unwrap_or_default();
v.push(input.into());
self.matched_categories = Some(v);
self
}
pub fn set_matched_categories(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.matched_categories = input;
self
}
pub fn matched_details(
mut self,
k: impl Into<std::string::String>,
v: crate::model::CategoryDetails,
) -> Self {
let mut hash_map = self.matched_details.unwrap_or_default();
hash_map.insert(k.into(), v);
self.matched_details = Some(hash_map);
self
}
pub fn set_matched_details(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, crate::model::CategoryDetails>,
>,
) -> Self {
self.matched_details = input;
self
}
pub fn build(self) -> crate::model::Categories {
crate::model::Categories {
matched_categories: self.matched_categories,
matched_details: self.matched_details,
}
}
}
}
impl Categories {
pub fn builder() -> crate::model::categories::Builder {
crate::model::categories::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CategoryDetails {
#[doc(hidden)]
pub points_of_interest: std::option::Option<std::vec::Vec<crate::model::PointOfInterest>>,
}
impl CategoryDetails {
pub fn points_of_interest(&self) -> std::option::Option<&[crate::model::PointOfInterest]> {
self.points_of_interest.as_deref()
}
}
pub mod category_details {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) points_of_interest:
std::option::Option<std::vec::Vec<crate::model::PointOfInterest>>,
}
impl Builder {
pub fn points_of_interest(mut self, input: crate::model::PointOfInterest) -> Self {
let mut v = self.points_of_interest.unwrap_or_default();
v.push(input);
self.points_of_interest = Some(v);
self
}
pub fn set_points_of_interest(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PointOfInterest>>,
) -> Self {
self.points_of_interest = input;
self
}
pub fn build(self) -> crate::model::CategoryDetails {
crate::model::CategoryDetails {
points_of_interest: self.points_of_interest,
}
}
}
}
impl CategoryDetails {
pub fn builder() -> crate::model::category_details::Builder {
crate::model::category_details::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PointOfInterest {
#[doc(hidden)]
pub begin_offset_millis: i32,
#[doc(hidden)]
pub end_offset_millis: i32,
}
impl PointOfInterest {
pub fn begin_offset_millis(&self) -> i32 {
self.begin_offset_millis
}
pub fn end_offset_millis(&self) -> i32 {
self.end_offset_millis
}
}
pub mod point_of_interest {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) begin_offset_millis: std::option::Option<i32>,
pub(crate) end_offset_millis: std::option::Option<i32>,
}
impl Builder {
pub fn begin_offset_millis(mut self, input: i32) -> Self {
self.begin_offset_millis = Some(input);
self
}
pub fn set_begin_offset_millis(mut self, input: std::option::Option<i32>) -> Self {
self.begin_offset_millis = input;
self
}
pub fn end_offset_millis(mut self, input: i32) -> Self {
self.end_offset_millis = Some(input);
self
}
pub fn set_end_offset_millis(mut self, input: std::option::Option<i32>) -> Self {
self.end_offset_millis = input;
self
}
pub fn build(self) -> crate::model::PointOfInterest {
crate::model::PointOfInterest {
begin_offset_millis: self.begin_offset_millis.unwrap_or_default(),
end_offset_millis: self.end_offset_millis.unwrap_or_default(),
}
}
}
}
impl PointOfInterest {
pub fn builder() -> crate::model::point_of_interest::Builder {
crate::model::point_of_interest::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Transcript {
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub participant_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub participant_role: std::option::Option<std::string::String>,
#[doc(hidden)]
pub content: std::option::Option<std::string::String>,
#[doc(hidden)]
pub begin_offset_millis: i32,
#[doc(hidden)]
pub end_offset_millis: i32,
#[doc(hidden)]
pub sentiment: std::option::Option<crate::model::SentimentValue>,
#[doc(hidden)]
pub issues_detected: std::option::Option<std::vec::Vec<crate::model::IssueDetected>>,
}
impl Transcript {
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn participant_id(&self) -> std::option::Option<&str> {
self.participant_id.as_deref()
}
pub fn participant_role(&self) -> std::option::Option<&str> {
self.participant_role.as_deref()
}
pub fn content(&self) -> std::option::Option<&str> {
self.content.as_deref()
}
pub fn begin_offset_millis(&self) -> i32 {
self.begin_offset_millis
}
pub fn end_offset_millis(&self) -> i32 {
self.end_offset_millis
}
pub fn sentiment(&self) -> std::option::Option<&crate::model::SentimentValue> {
self.sentiment.as_ref()
}
pub fn issues_detected(&self) -> std::option::Option<&[crate::model::IssueDetected]> {
self.issues_detected.as_deref()
}
}
pub mod transcript {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) participant_id: std::option::Option<std::string::String>,
pub(crate) participant_role: std::option::Option<std::string::String>,
pub(crate) content: std::option::Option<std::string::String>,
pub(crate) begin_offset_millis: std::option::Option<i32>,
pub(crate) end_offset_millis: std::option::Option<i32>,
pub(crate) sentiment: std::option::Option<crate::model::SentimentValue>,
pub(crate) issues_detected: std::option::Option<std::vec::Vec<crate::model::IssueDetected>>,
}
impl Builder {
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn participant_id(mut self, input: impl Into<std::string::String>) -> Self {
self.participant_id = Some(input.into());
self
}
pub fn set_participant_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.participant_id = input;
self
}
pub fn participant_role(mut self, input: impl Into<std::string::String>) -> Self {
self.participant_role = Some(input.into());
self
}
pub fn set_participant_role(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.participant_role = input;
self
}
pub fn content(mut self, input: impl Into<std::string::String>) -> Self {
self.content = Some(input.into());
self
}
pub fn set_content(mut self, input: std::option::Option<std::string::String>) -> Self {
self.content = input;
self
}
pub fn begin_offset_millis(mut self, input: i32) -> Self {
self.begin_offset_millis = Some(input);
self
}
pub fn set_begin_offset_millis(mut self, input: std::option::Option<i32>) -> Self {
self.begin_offset_millis = input;
self
}
pub fn end_offset_millis(mut self, input: i32) -> Self {
self.end_offset_millis = Some(input);
self
}
pub fn set_end_offset_millis(mut self, input: std::option::Option<i32>) -> Self {
self.end_offset_millis = input;
self
}
pub fn sentiment(mut self, input: crate::model::SentimentValue) -> Self {
self.sentiment = Some(input);
self
}
pub fn set_sentiment(
mut self,
input: std::option::Option<crate::model::SentimentValue>,
) -> Self {
self.sentiment = input;
self
}
pub fn issues_detected(mut self, input: crate::model::IssueDetected) -> Self {
let mut v = self.issues_detected.unwrap_or_default();
v.push(input);
self.issues_detected = Some(v);
self
}
pub fn set_issues_detected(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::IssueDetected>>,
) -> Self {
self.issues_detected = input;
self
}
pub fn build(self) -> crate::model::Transcript {
crate::model::Transcript {
id: self.id,
participant_id: self.participant_id,
participant_role: self.participant_role,
content: self.content,
begin_offset_millis: self.begin_offset_millis.unwrap_or_default(),
end_offset_millis: self.end_offset_millis.unwrap_or_default(),
sentiment: self.sentiment,
issues_detected: self.issues_detected,
}
}
}
}
impl Transcript {
pub fn builder() -> crate::model::transcript::Builder {
crate::model::transcript::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct IssueDetected {
#[doc(hidden)]
pub character_offsets: std::option::Option<crate::model::CharacterOffsets>,
}
impl IssueDetected {
pub fn character_offsets(&self) -> std::option::Option<&crate::model::CharacterOffsets> {
self.character_offsets.as_ref()
}
}
pub mod issue_detected {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) character_offsets: std::option::Option<crate::model::CharacterOffsets>,
}
impl Builder {
pub fn character_offsets(mut self, input: crate::model::CharacterOffsets) -> Self {
self.character_offsets = Some(input);
self
}
pub fn set_character_offsets(
mut self,
input: std::option::Option<crate::model::CharacterOffsets>,
) -> Self {
self.character_offsets = input;
self
}
pub fn build(self) -> crate::model::IssueDetected {
crate::model::IssueDetected {
character_offsets: self.character_offsets,
}
}
}
}
impl IssueDetected {
pub fn builder() -> crate::model::issue_detected::Builder {
crate::model::issue_detected::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CharacterOffsets {
#[doc(hidden)]
pub begin_offset_char: i32,
#[doc(hidden)]
pub end_offset_char: i32,
}
impl CharacterOffsets {
pub fn begin_offset_char(&self) -> i32 {
self.begin_offset_char
}
pub fn end_offset_char(&self) -> i32 {
self.end_offset_char
}
}
pub mod character_offsets {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) begin_offset_char: std::option::Option<i32>,
pub(crate) end_offset_char: std::option::Option<i32>,
}
impl Builder {
pub fn begin_offset_char(mut self, input: i32) -> Self {
self.begin_offset_char = Some(input);
self
}
pub fn set_begin_offset_char(mut self, input: std::option::Option<i32>) -> Self {
self.begin_offset_char = input;
self
}
pub fn end_offset_char(mut self, input: i32) -> Self {
self.end_offset_char = Some(input);
self
}
pub fn set_end_offset_char(mut self, input: std::option::Option<i32>) -> Self {
self.end_offset_char = input;
self
}
pub fn build(self) -> crate::model::CharacterOffsets {
crate::model::CharacterOffsets {
begin_offset_char: self.begin_offset_char.unwrap_or_default(),
end_offset_char: self.end_offset_char.unwrap_or_default(),
}
}
}
}
impl CharacterOffsets {
pub fn builder() -> crate::model::character_offsets::Builder {
crate::model::character_offsets::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 SentimentValue {
#[allow(missing_docs)] Negative,
#[allow(missing_docs)] Neutral,
#[allow(missing_docs)] Positive,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for SentimentValue {
fn from(s: &str) -> Self {
match s {
"NEGATIVE" => SentimentValue::Negative,
"NEUTRAL" => SentimentValue::Neutral,
"POSITIVE" => SentimentValue::Positive,
other => SentimentValue::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for SentimentValue {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SentimentValue::from(s))
}
}
impl SentimentValue {
pub fn as_str(&self) -> &str {
match self {
SentimentValue::Negative => "NEGATIVE",
SentimentValue::Neutral => "NEUTRAL",
SentimentValue::Positive => "POSITIVE",
SentimentValue::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["NEGATIVE", "NEUTRAL", "POSITIVE"]
}
}
impl AsRef<str> for SentimentValue {
fn as_ref(&self) -> &str {
self.as_str()
}
}