#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BadRequestDetail {
#[doc(hidden)]
pub code_errors: std::option::Option<std::vec::Vec<crate::model::CodeError>>,
}
impl BadRequestDetail {
pub fn code_errors(&self) -> std::option::Option<&[crate::model::CodeError]> {
self.code_errors.as_deref()
}
}
pub mod bad_request_detail {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) code_errors: std::option::Option<std::vec::Vec<crate::model::CodeError>>,
}
impl Builder {
pub fn code_errors(mut self, input: crate::model::CodeError) -> Self {
let mut v = self.code_errors.unwrap_or_default();
v.push(input);
self.code_errors = Some(v);
self
}
pub fn set_code_errors(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CodeError>>,
) -> Self {
self.code_errors = input;
self
}
pub fn build(self) -> crate::model::BadRequestDetail {
crate::model::BadRequestDetail {
code_errors: self.code_errors,
}
}
}
}
impl BadRequestDetail {
pub fn builder() -> crate::model::bad_request_detail::Builder {
crate::model::bad_request_detail::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CodeError {
#[doc(hidden)]
pub error_type: std::option::Option<std::string::String>,
#[doc(hidden)]
pub value: std::option::Option<std::string::String>,
#[doc(hidden)]
pub location: std::option::Option<crate::model::CodeErrorLocation>,
}
impl CodeError {
pub fn error_type(&self) -> std::option::Option<&str> {
self.error_type.as_deref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
pub fn location(&self) -> std::option::Option<&crate::model::CodeErrorLocation> {
self.location.as_ref()
}
}
pub mod code_error {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) error_type: std::option::Option<std::string::String>,
pub(crate) value: std::option::Option<std::string::String>,
pub(crate) location: std::option::Option<crate::model::CodeErrorLocation>,
}
impl Builder {
pub fn error_type(mut self, input: impl Into<std::string::String>) -> Self {
self.error_type = Some(input.into());
self
}
pub fn set_error_type(mut self, input: std::option::Option<std::string::String>) -> Self {
self.error_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 location(mut self, input: crate::model::CodeErrorLocation) -> Self {
self.location = Some(input);
self
}
pub fn set_location(
mut self,
input: std::option::Option<crate::model::CodeErrorLocation>,
) -> Self {
self.location = input;
self
}
pub fn build(self) -> crate::model::CodeError {
crate::model::CodeError {
error_type: self.error_type,
value: self.value,
location: self.location,
}
}
}
}
impl CodeError {
pub fn builder() -> crate::model::code_error::Builder {
crate::model::code_error::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CodeErrorLocation {
#[doc(hidden)]
pub line: i32,
#[doc(hidden)]
pub column: i32,
#[doc(hidden)]
pub span: i32,
}
impl CodeErrorLocation {
pub fn line(&self) -> i32 {
self.line
}
pub fn column(&self) -> i32 {
self.column
}
pub fn span(&self) -> i32 {
self.span
}
}
pub mod code_error_location {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) line: std::option::Option<i32>,
pub(crate) column: std::option::Option<i32>,
pub(crate) span: std::option::Option<i32>,
}
impl Builder {
pub fn line(mut self, input: i32) -> Self {
self.line = Some(input);
self
}
pub fn set_line(mut self, input: std::option::Option<i32>) -> Self {
self.line = input;
self
}
pub fn column(mut self, input: i32) -> Self {
self.column = Some(input);
self
}
pub fn set_column(mut self, input: std::option::Option<i32>) -> Self {
self.column = input;
self
}
pub fn span(mut self, input: i32) -> Self {
self.span = Some(input);
self
}
pub fn set_span(mut self, input: std::option::Option<i32>) -> Self {
self.span = input;
self
}
pub fn build(self) -> crate::model::CodeErrorLocation {
crate::model::CodeErrorLocation {
line: self.line.unwrap_or_default(),
column: self.column.unwrap_or_default(),
span: self.span.unwrap_or_default(),
}
}
}
}
impl CodeErrorLocation {
pub fn builder() -> crate::model::code_error_location::Builder {
crate::model::code_error_location::Builder::default()
}
}
#[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 BadRequestReason {
#[allow(missing_docs)] CodeError,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for BadRequestReason {
fn from(s: &str) -> Self {
match s {
"CODE_ERROR" => BadRequestReason::CodeError,
other => BadRequestReason::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for BadRequestReason {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(BadRequestReason::from(s))
}
}
impl BadRequestReason {
pub fn as_str(&self) -> &str {
match self {
BadRequestReason::CodeError => "CODE_ERROR",
BadRequestReason::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["CODE_ERROR"]
}
}
impl AsRef<str> for BadRequestReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Type {
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub definition: std::option::Option<std::string::String>,
#[doc(hidden)]
pub format: std::option::Option<crate::model::TypeDefinitionFormat>,
}
impl Type {
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 arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn definition(&self) -> std::option::Option<&str> {
self.definition.as_deref()
}
pub fn format(&self) -> std::option::Option<&crate::model::TypeDefinitionFormat> {
self.format.as_ref()
}
}
pub mod r#type {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) definition: std::option::Option<std::string::String>,
pub(crate) format: std::option::Option<crate::model::TypeDefinitionFormat>,
}
impl Builder {
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 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 definition(mut self, input: impl Into<std::string::String>) -> Self {
self.definition = Some(input.into());
self
}
pub fn set_definition(mut self, input: std::option::Option<std::string::String>) -> Self {
self.definition = input;
self
}
pub fn format(mut self, input: crate::model::TypeDefinitionFormat) -> Self {
self.format = Some(input);
self
}
pub fn set_format(
mut self,
input: std::option::Option<crate::model::TypeDefinitionFormat>,
) -> Self {
self.format = input;
self
}
pub fn build(self) -> crate::model::Type {
crate::model::Type {
name: self.name,
description: self.description,
arn: self.arn,
definition: self.definition,
format: self.format,
}
}
}
}
impl Type {
pub fn builder() -> crate::model::r#type::Builder {
crate::model::r#type::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 TypeDefinitionFormat {
#[allow(missing_docs)] Json,
#[allow(missing_docs)] Sdl,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for TypeDefinitionFormat {
fn from(s: &str) -> Self {
match s {
"JSON" => TypeDefinitionFormat::Json,
"SDL" => TypeDefinitionFormat::Sdl,
other => {
TypeDefinitionFormat::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for TypeDefinitionFormat {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(TypeDefinitionFormat::from(s))
}
}
impl TypeDefinitionFormat {
pub fn as_str(&self) -> &str {
match self {
TypeDefinitionFormat::Json => "JSON",
TypeDefinitionFormat::Sdl => "SDL",
TypeDefinitionFormat::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["JSON", "SDL"]
}
}
impl AsRef<str> for TypeDefinitionFormat {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Resolver {
#[doc(hidden)]
pub type_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub field_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub data_source_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub resolver_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub request_mapping_template: std::option::Option<std::string::String>,
#[doc(hidden)]
pub response_mapping_template: std::option::Option<std::string::String>,
#[doc(hidden)]
pub kind: std::option::Option<crate::model::ResolverKind>,
#[doc(hidden)]
pub pipeline_config: std::option::Option<crate::model::PipelineConfig>,
#[doc(hidden)]
pub sync_config: std::option::Option<crate::model::SyncConfig>,
#[doc(hidden)]
pub caching_config: std::option::Option<crate::model::CachingConfig>,
#[doc(hidden)]
pub max_batch_size: i32,
#[doc(hidden)]
pub runtime: std::option::Option<crate::model::AppSyncRuntime>,
#[doc(hidden)]
pub code: std::option::Option<std::string::String>,
}
impl Resolver {
pub fn type_name(&self) -> std::option::Option<&str> {
self.type_name.as_deref()
}
pub fn field_name(&self) -> std::option::Option<&str> {
self.field_name.as_deref()
}
pub fn data_source_name(&self) -> std::option::Option<&str> {
self.data_source_name.as_deref()
}
pub fn resolver_arn(&self) -> std::option::Option<&str> {
self.resolver_arn.as_deref()
}
pub fn request_mapping_template(&self) -> std::option::Option<&str> {
self.request_mapping_template.as_deref()
}
pub fn response_mapping_template(&self) -> std::option::Option<&str> {
self.response_mapping_template.as_deref()
}
pub fn kind(&self) -> std::option::Option<&crate::model::ResolverKind> {
self.kind.as_ref()
}
pub fn pipeline_config(&self) -> std::option::Option<&crate::model::PipelineConfig> {
self.pipeline_config.as_ref()
}
pub fn sync_config(&self) -> std::option::Option<&crate::model::SyncConfig> {
self.sync_config.as_ref()
}
pub fn caching_config(&self) -> std::option::Option<&crate::model::CachingConfig> {
self.caching_config.as_ref()
}
pub fn max_batch_size(&self) -> i32 {
self.max_batch_size
}
pub fn runtime(&self) -> std::option::Option<&crate::model::AppSyncRuntime> {
self.runtime.as_ref()
}
pub fn code(&self) -> std::option::Option<&str> {
self.code.as_deref()
}
}
pub mod resolver {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) type_name: std::option::Option<std::string::String>,
pub(crate) field_name: std::option::Option<std::string::String>,
pub(crate) data_source_name: std::option::Option<std::string::String>,
pub(crate) resolver_arn: std::option::Option<std::string::String>,
pub(crate) request_mapping_template: std::option::Option<std::string::String>,
pub(crate) response_mapping_template: std::option::Option<std::string::String>,
pub(crate) kind: std::option::Option<crate::model::ResolverKind>,
pub(crate) pipeline_config: std::option::Option<crate::model::PipelineConfig>,
pub(crate) sync_config: std::option::Option<crate::model::SyncConfig>,
pub(crate) caching_config: std::option::Option<crate::model::CachingConfig>,
pub(crate) max_batch_size: std::option::Option<i32>,
pub(crate) runtime: std::option::Option<crate::model::AppSyncRuntime>,
pub(crate) code: std::option::Option<std::string::String>,
}
impl Builder {
pub fn type_name(mut self, input: impl Into<std::string::String>) -> Self {
self.type_name = Some(input.into());
self
}
pub fn set_type_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.type_name = input;
self
}
pub fn field_name(mut self, input: impl Into<std::string::String>) -> Self {
self.field_name = Some(input.into());
self
}
pub fn set_field_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.field_name = input;
self
}
pub fn data_source_name(mut self, input: impl Into<std::string::String>) -> Self {
self.data_source_name = Some(input.into());
self
}
pub fn set_data_source_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.data_source_name = input;
self
}
pub fn resolver_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resolver_arn = Some(input.into());
self
}
pub fn set_resolver_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resolver_arn = input;
self
}
pub fn request_mapping_template(mut self, input: impl Into<std::string::String>) -> Self {
self.request_mapping_template = Some(input.into());
self
}
pub fn set_request_mapping_template(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_mapping_template = input;
self
}
pub fn response_mapping_template(mut self, input: impl Into<std::string::String>) -> Self {
self.response_mapping_template = Some(input.into());
self
}
pub fn set_response_mapping_template(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.response_mapping_template = input;
self
}
pub fn kind(mut self, input: crate::model::ResolverKind) -> Self {
self.kind = Some(input);
self
}
pub fn set_kind(mut self, input: std::option::Option<crate::model::ResolverKind>) -> Self {
self.kind = input;
self
}
pub fn pipeline_config(mut self, input: crate::model::PipelineConfig) -> Self {
self.pipeline_config = Some(input);
self
}
pub fn set_pipeline_config(
mut self,
input: std::option::Option<crate::model::PipelineConfig>,
) -> Self {
self.pipeline_config = input;
self
}
pub fn sync_config(mut self, input: crate::model::SyncConfig) -> Self {
self.sync_config = Some(input);
self
}
pub fn set_sync_config(
mut self,
input: std::option::Option<crate::model::SyncConfig>,
) -> Self {
self.sync_config = input;
self
}
pub fn caching_config(mut self, input: crate::model::CachingConfig) -> Self {
self.caching_config = Some(input);
self
}
pub fn set_caching_config(
mut self,
input: std::option::Option<crate::model::CachingConfig>,
) -> Self {
self.caching_config = input;
self
}
pub fn max_batch_size(mut self, input: i32) -> Self {
self.max_batch_size = Some(input);
self
}
pub fn set_max_batch_size(mut self, input: std::option::Option<i32>) -> Self {
self.max_batch_size = input;
self
}
pub fn runtime(mut self, input: crate::model::AppSyncRuntime) -> Self {
self.runtime = Some(input);
self
}
pub fn set_runtime(
mut self,
input: std::option::Option<crate::model::AppSyncRuntime>,
) -> Self {
self.runtime = input;
self
}
pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
self.code = Some(input.into());
self
}
pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
self.code = input;
self
}
pub fn build(self) -> crate::model::Resolver {
crate::model::Resolver {
type_name: self.type_name,
field_name: self.field_name,
data_source_name: self.data_source_name,
resolver_arn: self.resolver_arn,
request_mapping_template: self.request_mapping_template,
response_mapping_template: self.response_mapping_template,
kind: self.kind,
pipeline_config: self.pipeline_config,
sync_config: self.sync_config,
caching_config: self.caching_config,
max_batch_size: self.max_batch_size.unwrap_or_default(),
runtime: self.runtime,
code: self.code,
}
}
}
}
impl Resolver {
pub fn builder() -> crate::model::resolver::Builder {
crate::model::resolver::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AppSyncRuntime {
#[doc(hidden)]
pub name: std::option::Option<crate::model::RuntimeName>,
#[doc(hidden)]
pub runtime_version: std::option::Option<std::string::String>,
}
impl AppSyncRuntime {
pub fn name(&self) -> std::option::Option<&crate::model::RuntimeName> {
self.name.as_ref()
}
pub fn runtime_version(&self) -> std::option::Option<&str> {
self.runtime_version.as_deref()
}
}
pub mod app_sync_runtime {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<crate::model::RuntimeName>,
pub(crate) runtime_version: std::option::Option<std::string::String>,
}
impl Builder {
pub fn name(mut self, input: crate::model::RuntimeName) -> Self {
self.name = Some(input);
self
}
pub fn set_name(mut self, input: std::option::Option<crate::model::RuntimeName>) -> Self {
self.name = input;
self
}
pub fn runtime_version(mut self, input: impl Into<std::string::String>) -> Self {
self.runtime_version = Some(input.into());
self
}
pub fn set_runtime_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.runtime_version = input;
self
}
pub fn build(self) -> crate::model::AppSyncRuntime {
crate::model::AppSyncRuntime {
name: self.name,
runtime_version: self.runtime_version,
}
}
}
}
impl AppSyncRuntime {
pub fn builder() -> crate::model::app_sync_runtime::Builder {
crate::model::app_sync_runtime::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 RuntimeName {
#[allow(missing_docs)] AppsyncJs,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for RuntimeName {
fn from(s: &str) -> Self {
match s {
"APPSYNC_JS" => RuntimeName::AppsyncJs,
other => RuntimeName::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for RuntimeName {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(RuntimeName::from(s))
}
}
impl RuntimeName {
pub fn as_str(&self) -> &str {
match self {
RuntimeName::AppsyncJs => "APPSYNC_JS",
RuntimeName::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["APPSYNC_JS"]
}
}
impl AsRef<str> for RuntimeName {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CachingConfig {
#[doc(hidden)]
pub ttl: i64,
#[doc(hidden)]
pub caching_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl CachingConfig {
pub fn ttl(&self) -> i64 {
self.ttl
}
pub fn caching_keys(&self) -> std::option::Option<&[std::string::String]> {
self.caching_keys.as_deref()
}
}
pub mod caching_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) ttl: std::option::Option<i64>,
pub(crate) caching_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn ttl(mut self, input: i64) -> Self {
self.ttl = Some(input);
self
}
pub fn set_ttl(mut self, input: std::option::Option<i64>) -> Self {
self.ttl = input;
self
}
pub fn caching_keys(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.caching_keys.unwrap_or_default();
v.push(input.into());
self.caching_keys = Some(v);
self
}
pub fn set_caching_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.caching_keys = input;
self
}
pub fn build(self) -> crate::model::CachingConfig {
crate::model::CachingConfig {
ttl: self.ttl.unwrap_or_default(),
caching_keys: self.caching_keys,
}
}
}
}
impl CachingConfig {
pub fn builder() -> crate::model::caching_config::Builder {
crate::model::caching_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SyncConfig {
#[doc(hidden)]
pub conflict_handler: std::option::Option<crate::model::ConflictHandlerType>,
#[doc(hidden)]
pub conflict_detection: std::option::Option<crate::model::ConflictDetectionType>,
#[doc(hidden)]
pub lambda_conflict_handler_config:
std::option::Option<crate::model::LambdaConflictHandlerConfig>,
}
impl SyncConfig {
pub fn conflict_handler(&self) -> std::option::Option<&crate::model::ConflictHandlerType> {
self.conflict_handler.as_ref()
}
pub fn conflict_detection(&self) -> std::option::Option<&crate::model::ConflictDetectionType> {
self.conflict_detection.as_ref()
}
pub fn lambda_conflict_handler_config(
&self,
) -> std::option::Option<&crate::model::LambdaConflictHandlerConfig> {
self.lambda_conflict_handler_config.as_ref()
}
}
pub mod sync_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) conflict_handler: std::option::Option<crate::model::ConflictHandlerType>,
pub(crate) conflict_detection: std::option::Option<crate::model::ConflictDetectionType>,
pub(crate) lambda_conflict_handler_config:
std::option::Option<crate::model::LambdaConflictHandlerConfig>,
}
impl Builder {
pub fn conflict_handler(mut self, input: crate::model::ConflictHandlerType) -> Self {
self.conflict_handler = Some(input);
self
}
pub fn set_conflict_handler(
mut self,
input: std::option::Option<crate::model::ConflictHandlerType>,
) -> Self {
self.conflict_handler = input;
self
}
pub fn conflict_detection(mut self, input: crate::model::ConflictDetectionType) -> Self {
self.conflict_detection = Some(input);
self
}
pub fn set_conflict_detection(
mut self,
input: std::option::Option<crate::model::ConflictDetectionType>,
) -> Self {
self.conflict_detection = input;
self
}
pub fn lambda_conflict_handler_config(
mut self,
input: crate::model::LambdaConflictHandlerConfig,
) -> Self {
self.lambda_conflict_handler_config = Some(input);
self
}
pub fn set_lambda_conflict_handler_config(
mut self,
input: std::option::Option<crate::model::LambdaConflictHandlerConfig>,
) -> Self {
self.lambda_conflict_handler_config = input;
self
}
pub fn build(self) -> crate::model::SyncConfig {
crate::model::SyncConfig {
conflict_handler: self.conflict_handler,
conflict_detection: self.conflict_detection,
lambda_conflict_handler_config: self.lambda_conflict_handler_config,
}
}
}
}
impl SyncConfig {
pub fn builder() -> crate::model::sync_config::Builder {
crate::model::sync_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LambdaConflictHandlerConfig {
#[doc(hidden)]
pub lambda_conflict_handler_arn: std::option::Option<std::string::String>,
}
impl LambdaConflictHandlerConfig {
pub fn lambda_conflict_handler_arn(&self) -> std::option::Option<&str> {
self.lambda_conflict_handler_arn.as_deref()
}
}
pub mod lambda_conflict_handler_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) lambda_conflict_handler_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn lambda_conflict_handler_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.lambda_conflict_handler_arn = Some(input.into());
self
}
pub fn set_lambda_conflict_handler_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.lambda_conflict_handler_arn = input;
self
}
pub fn build(self) -> crate::model::LambdaConflictHandlerConfig {
crate::model::LambdaConflictHandlerConfig {
lambda_conflict_handler_arn: self.lambda_conflict_handler_arn,
}
}
}
}
impl LambdaConflictHandlerConfig {
pub fn builder() -> crate::model::lambda_conflict_handler_config::Builder {
crate::model::lambda_conflict_handler_config::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 ConflictDetectionType {
#[allow(missing_docs)] None,
#[allow(missing_docs)] Version,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ConflictDetectionType {
fn from(s: &str) -> Self {
match s {
"NONE" => ConflictDetectionType::None,
"VERSION" => ConflictDetectionType::Version,
other => {
ConflictDetectionType::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for ConflictDetectionType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ConflictDetectionType::from(s))
}
}
impl ConflictDetectionType {
pub fn as_str(&self) -> &str {
match self {
ConflictDetectionType::None => "NONE",
ConflictDetectionType::Version => "VERSION",
ConflictDetectionType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["NONE", "VERSION"]
}
}
impl AsRef<str> for ConflictDetectionType {
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 ConflictHandlerType {
#[allow(missing_docs)] Automerge,
#[allow(missing_docs)] Lambda,
#[allow(missing_docs)] None,
#[allow(missing_docs)] OptimisticConcurrency,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ConflictHandlerType {
fn from(s: &str) -> Self {
match s {
"AUTOMERGE" => ConflictHandlerType::Automerge,
"LAMBDA" => ConflictHandlerType::Lambda,
"NONE" => ConflictHandlerType::None,
"OPTIMISTIC_CONCURRENCY" => ConflictHandlerType::OptimisticConcurrency,
other => {
ConflictHandlerType::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for ConflictHandlerType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ConflictHandlerType::from(s))
}
}
impl ConflictHandlerType {
pub fn as_str(&self) -> &str {
match self {
ConflictHandlerType::Automerge => "AUTOMERGE",
ConflictHandlerType::Lambda => "LAMBDA",
ConflictHandlerType::None => "NONE",
ConflictHandlerType::OptimisticConcurrency => "OPTIMISTIC_CONCURRENCY",
ConflictHandlerType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["AUTOMERGE", "LAMBDA", "NONE", "OPTIMISTIC_CONCURRENCY"]
}
}
impl AsRef<str> for ConflictHandlerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PipelineConfig {
#[doc(hidden)]
pub functions: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl PipelineConfig {
pub fn functions(&self) -> std::option::Option<&[std::string::String]> {
self.functions.as_deref()
}
}
pub mod pipeline_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) functions: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn functions(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.functions.unwrap_or_default();
v.push(input.into());
self.functions = Some(v);
self
}
pub fn set_functions(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.functions = input;
self
}
pub fn build(self) -> crate::model::PipelineConfig {
crate::model::PipelineConfig {
functions: self.functions,
}
}
}
}
impl PipelineConfig {
pub fn builder() -> crate::model::pipeline_config::Builder {
crate::model::pipeline_config::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 ResolverKind {
#[allow(missing_docs)] Pipeline,
#[allow(missing_docs)] Unit,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ResolverKind {
fn from(s: &str) -> Self {
match s {
"PIPELINE" => ResolverKind::Pipeline,
"UNIT" => ResolverKind::Unit,
other => ResolverKind::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for ResolverKind {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ResolverKind::from(s))
}
}
impl ResolverKind {
pub fn as_str(&self) -> &str {
match self {
ResolverKind::Pipeline => "PIPELINE",
ResolverKind::Unit => "UNIT",
ResolverKind::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["PIPELINE", "UNIT"]
}
}
impl AsRef<str> for ResolverKind {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GraphqlApi {
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub api_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub authentication_type: std::option::Option<crate::model::AuthenticationType>,
#[doc(hidden)]
pub log_config: std::option::Option<crate::model::LogConfig>,
#[doc(hidden)]
pub user_pool_config: std::option::Option<crate::model::UserPoolConfig>,
#[doc(hidden)]
pub open_id_connect_config: std::option::Option<crate::model::OpenIdConnectConfig>,
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub uris:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
#[doc(hidden)]
pub additional_authentication_providers:
std::option::Option<std::vec::Vec<crate::model::AdditionalAuthenticationProvider>>,
#[doc(hidden)]
pub xray_enabled: bool,
#[doc(hidden)]
pub waf_web_acl_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub lambda_authorizer_config: std::option::Option<crate::model::LambdaAuthorizerConfig>,
}
impl GraphqlApi {
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn api_id(&self) -> std::option::Option<&str> {
self.api_id.as_deref()
}
pub fn authentication_type(&self) -> std::option::Option<&crate::model::AuthenticationType> {
self.authentication_type.as_ref()
}
pub fn log_config(&self) -> std::option::Option<&crate::model::LogConfig> {
self.log_config.as_ref()
}
pub fn user_pool_config(&self) -> std::option::Option<&crate::model::UserPoolConfig> {
self.user_pool_config.as_ref()
}
pub fn open_id_connect_config(
&self,
) -> std::option::Option<&crate::model::OpenIdConnectConfig> {
self.open_id_connect_config.as_ref()
}
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn uris(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.uris.as_ref()
}
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
pub fn additional_authentication_providers(
&self,
) -> std::option::Option<&[crate::model::AdditionalAuthenticationProvider]> {
self.additional_authentication_providers.as_deref()
}
pub fn xray_enabled(&self) -> bool {
self.xray_enabled
}
pub fn waf_web_acl_arn(&self) -> std::option::Option<&str> {
self.waf_web_acl_arn.as_deref()
}
pub fn lambda_authorizer_config(
&self,
) -> std::option::Option<&crate::model::LambdaAuthorizerConfig> {
self.lambda_authorizer_config.as_ref()
}
}
pub mod graphql_api {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) api_id: std::option::Option<std::string::String>,
pub(crate) authentication_type: std::option::Option<crate::model::AuthenticationType>,
pub(crate) log_config: std::option::Option<crate::model::LogConfig>,
pub(crate) user_pool_config: std::option::Option<crate::model::UserPoolConfig>,
pub(crate) open_id_connect_config: std::option::Option<crate::model::OpenIdConnectConfig>,
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) uris: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) additional_authentication_providers:
std::option::Option<std::vec::Vec<crate::model::AdditionalAuthenticationProvider>>,
pub(crate) xray_enabled: std::option::Option<bool>,
pub(crate) waf_web_acl_arn: std::option::Option<std::string::String>,
pub(crate) lambda_authorizer_config:
std::option::Option<crate::model::LambdaAuthorizerConfig>,
}
impl Builder {
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 api_id(mut self, input: impl Into<std::string::String>) -> Self {
self.api_id = Some(input.into());
self
}
pub fn set_api_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.api_id = input;
self
}
pub fn authentication_type(mut self, input: crate::model::AuthenticationType) -> Self {
self.authentication_type = Some(input);
self
}
pub fn set_authentication_type(
mut self,
input: std::option::Option<crate::model::AuthenticationType>,
) -> Self {
self.authentication_type = input;
self
}
pub fn log_config(mut self, input: crate::model::LogConfig) -> Self {
self.log_config = Some(input);
self
}
pub fn set_log_config(
mut self,
input: std::option::Option<crate::model::LogConfig>,
) -> Self {
self.log_config = input;
self
}
pub fn user_pool_config(mut self, input: crate::model::UserPoolConfig) -> Self {
self.user_pool_config = Some(input);
self
}
pub fn set_user_pool_config(
mut self,
input: std::option::Option<crate::model::UserPoolConfig>,
) -> Self {
self.user_pool_config = input;
self
}
pub fn open_id_connect_config(mut self, input: crate::model::OpenIdConnectConfig) -> Self {
self.open_id_connect_config = Some(input);
self
}
pub fn set_open_id_connect_config(
mut self,
input: std::option::Option<crate::model::OpenIdConnectConfig>,
) -> Self {
self.open_id_connect_config = input;
self
}
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 uris(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.uris.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.uris = Some(hash_map);
self
}
pub fn set_uris(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.uris = input;
self
}
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
pub fn additional_authentication_providers(
mut self,
input: crate::model::AdditionalAuthenticationProvider,
) -> Self {
let mut v = self.additional_authentication_providers.unwrap_or_default();
v.push(input);
self.additional_authentication_providers = Some(v);
self
}
pub fn set_additional_authentication_providers(
mut self,
input: std::option::Option<
std::vec::Vec<crate::model::AdditionalAuthenticationProvider>,
>,
) -> Self {
self.additional_authentication_providers = input;
self
}
pub fn xray_enabled(mut self, input: bool) -> Self {
self.xray_enabled = Some(input);
self
}
pub fn set_xray_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.xray_enabled = input;
self
}
pub fn waf_web_acl_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.waf_web_acl_arn = Some(input.into());
self
}
pub fn set_waf_web_acl_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.waf_web_acl_arn = input;
self
}
pub fn lambda_authorizer_config(
mut self,
input: crate::model::LambdaAuthorizerConfig,
) -> Self {
self.lambda_authorizer_config = Some(input);
self
}
pub fn set_lambda_authorizer_config(
mut self,
input: std::option::Option<crate::model::LambdaAuthorizerConfig>,
) -> Self {
self.lambda_authorizer_config = input;
self
}
pub fn build(self) -> crate::model::GraphqlApi {
crate::model::GraphqlApi {
name: self.name,
api_id: self.api_id,
authentication_type: self.authentication_type,
log_config: self.log_config,
user_pool_config: self.user_pool_config,
open_id_connect_config: self.open_id_connect_config,
arn: self.arn,
uris: self.uris,
tags: self.tags,
additional_authentication_providers: self.additional_authentication_providers,
xray_enabled: self.xray_enabled.unwrap_or_default(),
waf_web_acl_arn: self.waf_web_acl_arn,
lambda_authorizer_config: self.lambda_authorizer_config,
}
}
}
}
impl GraphqlApi {
pub fn builder() -> crate::model::graphql_api::Builder {
crate::model::graphql_api::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LambdaAuthorizerConfig {
#[doc(hidden)]
pub authorizer_result_ttl_in_seconds: i32,
#[doc(hidden)]
pub authorizer_uri: std::option::Option<std::string::String>,
#[doc(hidden)]
pub identity_validation_expression: std::option::Option<std::string::String>,
}
impl LambdaAuthorizerConfig {
pub fn authorizer_result_ttl_in_seconds(&self) -> i32 {
self.authorizer_result_ttl_in_seconds
}
pub fn authorizer_uri(&self) -> std::option::Option<&str> {
self.authorizer_uri.as_deref()
}
pub fn identity_validation_expression(&self) -> std::option::Option<&str> {
self.identity_validation_expression.as_deref()
}
}
pub mod lambda_authorizer_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) authorizer_result_ttl_in_seconds: std::option::Option<i32>,
pub(crate) authorizer_uri: std::option::Option<std::string::String>,
pub(crate) identity_validation_expression: std::option::Option<std::string::String>,
}
impl Builder {
pub fn authorizer_result_ttl_in_seconds(mut self, input: i32) -> Self {
self.authorizer_result_ttl_in_seconds = Some(input);
self
}
pub fn set_authorizer_result_ttl_in_seconds(
mut self,
input: std::option::Option<i32>,
) -> Self {
self.authorizer_result_ttl_in_seconds = input;
self
}
pub fn authorizer_uri(mut self, input: impl Into<std::string::String>) -> Self {
self.authorizer_uri = Some(input.into());
self
}
pub fn set_authorizer_uri(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.authorizer_uri = input;
self
}
pub fn identity_validation_expression(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.identity_validation_expression = Some(input.into());
self
}
pub fn set_identity_validation_expression(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.identity_validation_expression = input;
self
}
pub fn build(self) -> crate::model::LambdaAuthorizerConfig {
crate::model::LambdaAuthorizerConfig {
authorizer_result_ttl_in_seconds: self
.authorizer_result_ttl_in_seconds
.unwrap_or_default(),
authorizer_uri: self.authorizer_uri,
identity_validation_expression: self.identity_validation_expression,
}
}
}
}
impl LambdaAuthorizerConfig {
pub fn builder() -> crate::model::lambda_authorizer_config::Builder {
crate::model::lambda_authorizer_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AdditionalAuthenticationProvider {
#[doc(hidden)]
pub authentication_type: std::option::Option<crate::model::AuthenticationType>,
#[doc(hidden)]
pub open_id_connect_config: std::option::Option<crate::model::OpenIdConnectConfig>,
#[doc(hidden)]
pub user_pool_config: std::option::Option<crate::model::CognitoUserPoolConfig>,
#[doc(hidden)]
pub lambda_authorizer_config: std::option::Option<crate::model::LambdaAuthorizerConfig>,
}
impl AdditionalAuthenticationProvider {
pub fn authentication_type(&self) -> std::option::Option<&crate::model::AuthenticationType> {
self.authentication_type.as_ref()
}
pub fn open_id_connect_config(
&self,
) -> std::option::Option<&crate::model::OpenIdConnectConfig> {
self.open_id_connect_config.as_ref()
}
pub fn user_pool_config(&self) -> std::option::Option<&crate::model::CognitoUserPoolConfig> {
self.user_pool_config.as_ref()
}
pub fn lambda_authorizer_config(
&self,
) -> std::option::Option<&crate::model::LambdaAuthorizerConfig> {
self.lambda_authorizer_config.as_ref()
}
}
pub mod additional_authentication_provider {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) authentication_type: std::option::Option<crate::model::AuthenticationType>,
pub(crate) open_id_connect_config: std::option::Option<crate::model::OpenIdConnectConfig>,
pub(crate) user_pool_config: std::option::Option<crate::model::CognitoUserPoolConfig>,
pub(crate) lambda_authorizer_config:
std::option::Option<crate::model::LambdaAuthorizerConfig>,
}
impl Builder {
pub fn authentication_type(mut self, input: crate::model::AuthenticationType) -> Self {
self.authentication_type = Some(input);
self
}
pub fn set_authentication_type(
mut self,
input: std::option::Option<crate::model::AuthenticationType>,
) -> Self {
self.authentication_type = input;
self
}
pub fn open_id_connect_config(mut self, input: crate::model::OpenIdConnectConfig) -> Self {
self.open_id_connect_config = Some(input);
self
}
pub fn set_open_id_connect_config(
mut self,
input: std::option::Option<crate::model::OpenIdConnectConfig>,
) -> Self {
self.open_id_connect_config = input;
self
}
pub fn user_pool_config(mut self, input: crate::model::CognitoUserPoolConfig) -> Self {
self.user_pool_config = Some(input);
self
}
pub fn set_user_pool_config(
mut self,
input: std::option::Option<crate::model::CognitoUserPoolConfig>,
) -> Self {
self.user_pool_config = input;
self
}
pub fn lambda_authorizer_config(
mut self,
input: crate::model::LambdaAuthorizerConfig,
) -> Self {
self.lambda_authorizer_config = Some(input);
self
}
pub fn set_lambda_authorizer_config(
mut self,
input: std::option::Option<crate::model::LambdaAuthorizerConfig>,
) -> Self {
self.lambda_authorizer_config = input;
self
}
pub fn build(self) -> crate::model::AdditionalAuthenticationProvider {
crate::model::AdditionalAuthenticationProvider {
authentication_type: self.authentication_type,
open_id_connect_config: self.open_id_connect_config,
user_pool_config: self.user_pool_config,
lambda_authorizer_config: self.lambda_authorizer_config,
}
}
}
}
impl AdditionalAuthenticationProvider {
pub fn builder() -> crate::model::additional_authentication_provider::Builder {
crate::model::additional_authentication_provider::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CognitoUserPoolConfig {
#[doc(hidden)]
pub user_pool_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aws_region: std::option::Option<std::string::String>,
#[doc(hidden)]
pub app_id_client_regex: std::option::Option<std::string::String>,
}
impl CognitoUserPoolConfig {
pub fn user_pool_id(&self) -> std::option::Option<&str> {
self.user_pool_id.as_deref()
}
pub fn aws_region(&self) -> std::option::Option<&str> {
self.aws_region.as_deref()
}
pub fn app_id_client_regex(&self) -> std::option::Option<&str> {
self.app_id_client_regex.as_deref()
}
}
pub mod cognito_user_pool_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_pool_id: std::option::Option<std::string::String>,
pub(crate) aws_region: std::option::Option<std::string::String>,
pub(crate) app_id_client_regex: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_pool_id(mut self, input: impl Into<std::string::String>) -> Self {
self.user_pool_id = Some(input.into());
self
}
pub fn set_user_pool_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_pool_id = input;
self
}
pub fn aws_region(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_region = Some(input.into());
self
}
pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
self.aws_region = input;
self
}
pub fn app_id_client_regex(mut self, input: impl Into<std::string::String>) -> Self {
self.app_id_client_regex = Some(input.into());
self
}
pub fn set_app_id_client_regex(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.app_id_client_regex = input;
self
}
pub fn build(self) -> crate::model::CognitoUserPoolConfig {
crate::model::CognitoUserPoolConfig {
user_pool_id: self.user_pool_id,
aws_region: self.aws_region,
app_id_client_regex: self.app_id_client_regex,
}
}
}
}
impl CognitoUserPoolConfig {
pub fn builder() -> crate::model::cognito_user_pool_config::Builder {
crate::model::cognito_user_pool_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct OpenIdConnectConfig {
#[doc(hidden)]
pub issuer: std::option::Option<std::string::String>,
#[doc(hidden)]
pub client_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub iat_ttl: i64,
#[doc(hidden)]
pub auth_ttl: i64,
}
impl OpenIdConnectConfig {
pub fn issuer(&self) -> std::option::Option<&str> {
self.issuer.as_deref()
}
pub fn client_id(&self) -> std::option::Option<&str> {
self.client_id.as_deref()
}
pub fn iat_ttl(&self) -> i64 {
self.iat_ttl
}
pub fn auth_ttl(&self) -> i64 {
self.auth_ttl
}
}
pub mod open_id_connect_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) issuer: std::option::Option<std::string::String>,
pub(crate) client_id: std::option::Option<std::string::String>,
pub(crate) iat_ttl: std::option::Option<i64>,
pub(crate) auth_ttl: std::option::Option<i64>,
}
impl Builder {
pub fn issuer(mut self, input: impl Into<std::string::String>) -> Self {
self.issuer = Some(input.into());
self
}
pub fn set_issuer(mut self, input: std::option::Option<std::string::String>) -> Self {
self.issuer = input;
self
}
pub fn client_id(mut self, input: impl Into<std::string::String>) -> Self {
self.client_id = Some(input.into());
self
}
pub fn set_client_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.client_id = input;
self
}
pub fn iat_ttl(mut self, input: i64) -> Self {
self.iat_ttl = Some(input);
self
}
pub fn set_iat_ttl(mut self, input: std::option::Option<i64>) -> Self {
self.iat_ttl = input;
self
}
pub fn auth_ttl(mut self, input: i64) -> Self {
self.auth_ttl = Some(input);
self
}
pub fn set_auth_ttl(mut self, input: std::option::Option<i64>) -> Self {
self.auth_ttl = input;
self
}
pub fn build(self) -> crate::model::OpenIdConnectConfig {
crate::model::OpenIdConnectConfig {
issuer: self.issuer,
client_id: self.client_id,
iat_ttl: self.iat_ttl.unwrap_or_default(),
auth_ttl: self.auth_ttl.unwrap_or_default(),
}
}
}
}
impl OpenIdConnectConfig {
pub fn builder() -> crate::model::open_id_connect_config::Builder {
crate::model::open_id_connect_config::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 AuthenticationType {
#[allow(missing_docs)] AmazonCognitoUserPools,
#[allow(missing_docs)] ApiKey,
#[allow(missing_docs)] AwsIam,
#[allow(missing_docs)] AwsLambda,
#[allow(missing_docs)] OpenidConnect,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for AuthenticationType {
fn from(s: &str) -> Self {
match s {
"AMAZON_COGNITO_USER_POOLS" => AuthenticationType::AmazonCognitoUserPools,
"API_KEY" => AuthenticationType::ApiKey,
"AWS_IAM" => AuthenticationType::AwsIam,
"AWS_LAMBDA" => AuthenticationType::AwsLambda,
"OPENID_CONNECT" => AuthenticationType::OpenidConnect,
other => {
AuthenticationType::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for AuthenticationType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(AuthenticationType::from(s))
}
}
impl AuthenticationType {
pub fn as_str(&self) -> &str {
match self {
AuthenticationType::AmazonCognitoUserPools => "AMAZON_COGNITO_USER_POOLS",
AuthenticationType::ApiKey => "API_KEY",
AuthenticationType::AwsIam => "AWS_IAM",
AuthenticationType::AwsLambda => "AWS_LAMBDA",
AuthenticationType::OpenidConnect => "OPENID_CONNECT",
AuthenticationType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"AMAZON_COGNITO_USER_POOLS",
"API_KEY",
"AWS_IAM",
"AWS_LAMBDA",
"OPENID_CONNECT",
]
}
}
impl AsRef<str> for AuthenticationType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UserPoolConfig {
#[doc(hidden)]
pub user_pool_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aws_region: std::option::Option<std::string::String>,
#[doc(hidden)]
pub default_action: std::option::Option<crate::model::DefaultAction>,
#[doc(hidden)]
pub app_id_client_regex: std::option::Option<std::string::String>,
}
impl UserPoolConfig {
pub fn user_pool_id(&self) -> std::option::Option<&str> {
self.user_pool_id.as_deref()
}
pub fn aws_region(&self) -> std::option::Option<&str> {
self.aws_region.as_deref()
}
pub fn default_action(&self) -> std::option::Option<&crate::model::DefaultAction> {
self.default_action.as_ref()
}
pub fn app_id_client_regex(&self) -> std::option::Option<&str> {
self.app_id_client_regex.as_deref()
}
}
pub mod user_pool_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_pool_id: std::option::Option<std::string::String>,
pub(crate) aws_region: std::option::Option<std::string::String>,
pub(crate) default_action: std::option::Option<crate::model::DefaultAction>,
pub(crate) app_id_client_regex: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_pool_id(mut self, input: impl Into<std::string::String>) -> Self {
self.user_pool_id = Some(input.into());
self
}
pub fn set_user_pool_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_pool_id = input;
self
}
pub fn aws_region(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_region = Some(input.into());
self
}
pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
self.aws_region = input;
self
}
pub fn default_action(mut self, input: crate::model::DefaultAction) -> Self {
self.default_action = Some(input);
self
}
pub fn set_default_action(
mut self,
input: std::option::Option<crate::model::DefaultAction>,
) -> Self {
self.default_action = input;
self
}
pub fn app_id_client_regex(mut self, input: impl Into<std::string::String>) -> Self {
self.app_id_client_regex = Some(input.into());
self
}
pub fn set_app_id_client_regex(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.app_id_client_regex = input;
self
}
pub fn build(self) -> crate::model::UserPoolConfig {
crate::model::UserPoolConfig {
user_pool_id: self.user_pool_id,
aws_region: self.aws_region,
default_action: self.default_action,
app_id_client_regex: self.app_id_client_regex,
}
}
}
}
impl UserPoolConfig {
pub fn builder() -> crate::model::user_pool_config::Builder {
crate::model::user_pool_config::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 DefaultAction {
#[allow(missing_docs)] Allow,
#[allow(missing_docs)] Deny,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for DefaultAction {
fn from(s: &str) -> Self {
match s {
"ALLOW" => DefaultAction::Allow,
"DENY" => DefaultAction::Deny,
other => DefaultAction::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for DefaultAction {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DefaultAction::from(s))
}
}
impl DefaultAction {
pub fn as_str(&self) -> &str {
match self {
DefaultAction::Allow => "ALLOW",
DefaultAction::Deny => "DENY",
DefaultAction::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["ALLOW", "DENY"]
}
}
impl AsRef<str> for DefaultAction {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LogConfig {
#[doc(hidden)]
pub field_log_level: std::option::Option<crate::model::FieldLogLevel>,
#[doc(hidden)]
pub cloud_watch_logs_role_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub exclude_verbose_content: bool,
}
impl LogConfig {
pub fn field_log_level(&self) -> std::option::Option<&crate::model::FieldLogLevel> {
self.field_log_level.as_ref()
}
pub fn cloud_watch_logs_role_arn(&self) -> std::option::Option<&str> {
self.cloud_watch_logs_role_arn.as_deref()
}
pub fn exclude_verbose_content(&self) -> bool {
self.exclude_verbose_content
}
}
pub mod log_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) field_log_level: std::option::Option<crate::model::FieldLogLevel>,
pub(crate) cloud_watch_logs_role_arn: std::option::Option<std::string::String>,
pub(crate) exclude_verbose_content: std::option::Option<bool>,
}
impl Builder {
pub fn field_log_level(mut self, input: crate::model::FieldLogLevel) -> Self {
self.field_log_level = Some(input);
self
}
pub fn set_field_log_level(
mut self,
input: std::option::Option<crate::model::FieldLogLevel>,
) -> Self {
self.field_log_level = input;
self
}
pub fn cloud_watch_logs_role_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.cloud_watch_logs_role_arn = Some(input.into());
self
}
pub fn set_cloud_watch_logs_role_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.cloud_watch_logs_role_arn = input;
self
}
pub fn exclude_verbose_content(mut self, input: bool) -> Self {
self.exclude_verbose_content = Some(input);
self
}
pub fn set_exclude_verbose_content(mut self, input: std::option::Option<bool>) -> Self {
self.exclude_verbose_content = input;
self
}
pub fn build(self) -> crate::model::LogConfig {
crate::model::LogConfig {
field_log_level: self.field_log_level,
cloud_watch_logs_role_arn: self.cloud_watch_logs_role_arn,
exclude_verbose_content: self.exclude_verbose_content.unwrap_or_default(),
}
}
}
}
impl LogConfig {
pub fn builder() -> crate::model::log_config::Builder {
crate::model::log_config::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 FieldLogLevel {
#[allow(missing_docs)] All,
#[allow(missing_docs)] Error,
#[allow(missing_docs)] None,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for FieldLogLevel {
fn from(s: &str) -> Self {
match s {
"ALL" => FieldLogLevel::All,
"ERROR" => FieldLogLevel::Error,
"NONE" => FieldLogLevel::None,
other => FieldLogLevel::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for FieldLogLevel {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(FieldLogLevel::from(s))
}
}
impl FieldLogLevel {
pub fn as_str(&self) -> &str {
match self {
FieldLogLevel::All => "ALL",
FieldLogLevel::Error => "ERROR",
FieldLogLevel::None => "NONE",
FieldLogLevel::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["ALL", "ERROR", "NONE"]
}
}
impl AsRef<str> for FieldLogLevel {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionConfiguration {
#[doc(hidden)]
pub function_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub function_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
#[doc(hidden)]
pub data_source_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub request_mapping_template: std::option::Option<std::string::String>,
#[doc(hidden)]
pub response_mapping_template: std::option::Option<std::string::String>,
#[doc(hidden)]
pub function_version: std::option::Option<std::string::String>,
#[doc(hidden)]
pub sync_config: std::option::Option<crate::model::SyncConfig>,
#[doc(hidden)]
pub max_batch_size: i32,
#[doc(hidden)]
pub runtime: std::option::Option<crate::model::AppSyncRuntime>,
#[doc(hidden)]
pub code: std::option::Option<std::string::String>,
}
impl FunctionConfiguration {
pub fn function_id(&self) -> std::option::Option<&str> {
self.function_id.as_deref()
}
pub fn function_arn(&self) -> std::option::Option<&str> {
self.function_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 data_source_name(&self) -> std::option::Option<&str> {
self.data_source_name.as_deref()
}
pub fn request_mapping_template(&self) -> std::option::Option<&str> {
self.request_mapping_template.as_deref()
}
pub fn response_mapping_template(&self) -> std::option::Option<&str> {
self.response_mapping_template.as_deref()
}
pub fn function_version(&self) -> std::option::Option<&str> {
self.function_version.as_deref()
}
pub fn sync_config(&self) -> std::option::Option<&crate::model::SyncConfig> {
self.sync_config.as_ref()
}
pub fn max_batch_size(&self) -> i32 {
self.max_batch_size
}
pub fn runtime(&self) -> std::option::Option<&crate::model::AppSyncRuntime> {
self.runtime.as_ref()
}
pub fn code(&self) -> std::option::Option<&str> {
self.code.as_deref()
}
}
pub mod function_configuration {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) function_id: std::option::Option<std::string::String>,
pub(crate) function_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) data_source_name: std::option::Option<std::string::String>,
pub(crate) request_mapping_template: std::option::Option<std::string::String>,
pub(crate) response_mapping_template: std::option::Option<std::string::String>,
pub(crate) function_version: std::option::Option<std::string::String>,
pub(crate) sync_config: std::option::Option<crate::model::SyncConfig>,
pub(crate) max_batch_size: std::option::Option<i32>,
pub(crate) runtime: std::option::Option<crate::model::AppSyncRuntime>,
pub(crate) code: std::option::Option<std::string::String>,
}
impl Builder {
pub fn function_id(mut self, input: impl Into<std::string::String>) -> Self {
self.function_id = Some(input.into());
self
}
pub fn set_function_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.function_id = input;
self
}
pub fn function_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.function_arn = Some(input.into());
self
}
pub fn set_function_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.function_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 data_source_name(mut self, input: impl Into<std::string::String>) -> Self {
self.data_source_name = Some(input.into());
self
}
pub fn set_data_source_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.data_source_name = input;
self
}
pub fn request_mapping_template(mut self, input: impl Into<std::string::String>) -> Self {
self.request_mapping_template = Some(input.into());
self
}
pub fn set_request_mapping_template(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_mapping_template = input;
self
}
pub fn response_mapping_template(mut self, input: impl Into<std::string::String>) -> Self {
self.response_mapping_template = Some(input.into());
self
}
pub fn set_response_mapping_template(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.response_mapping_template = input;
self
}
pub fn function_version(mut self, input: impl Into<std::string::String>) -> Self {
self.function_version = Some(input.into());
self
}
pub fn set_function_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.function_version = input;
self
}
pub fn sync_config(mut self, input: crate::model::SyncConfig) -> Self {
self.sync_config = Some(input);
self
}
pub fn set_sync_config(
mut self,
input: std::option::Option<crate::model::SyncConfig>,
) -> Self {
self.sync_config = input;
self
}
pub fn max_batch_size(mut self, input: i32) -> Self {
self.max_batch_size = Some(input);
self
}
pub fn set_max_batch_size(mut self, input: std::option::Option<i32>) -> Self {
self.max_batch_size = input;
self
}
pub fn runtime(mut self, input: crate::model::AppSyncRuntime) -> Self {
self.runtime = Some(input);
self
}
pub fn set_runtime(
mut self,
input: std::option::Option<crate::model::AppSyncRuntime>,
) -> Self {
self.runtime = input;
self
}
pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
self.code = Some(input.into());
self
}
pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
self.code = input;
self
}
pub fn build(self) -> crate::model::FunctionConfiguration {
crate::model::FunctionConfiguration {
function_id: self.function_id,
function_arn: self.function_arn,
name: self.name,
description: self.description,
data_source_name: self.data_source_name,
request_mapping_template: self.request_mapping_template,
response_mapping_template: self.response_mapping_template,
function_version: self.function_version,
sync_config: self.sync_config,
max_batch_size: self.max_batch_size.unwrap_or_default(),
runtime: self.runtime,
code: self.code,
}
}
}
}
impl FunctionConfiguration {
pub fn builder() -> crate::model::function_configuration::Builder {
crate::model::function_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DomainNameConfig {
#[doc(hidden)]
pub domain_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
#[doc(hidden)]
pub certificate_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub appsync_domain_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub hosted_zone_id: std::option::Option<std::string::String>,
}
impl DomainNameConfig {
pub fn domain_name(&self) -> std::option::Option<&str> {
self.domain_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn certificate_arn(&self) -> std::option::Option<&str> {
self.certificate_arn.as_deref()
}
pub fn appsync_domain_name(&self) -> std::option::Option<&str> {
self.appsync_domain_name.as_deref()
}
pub fn hosted_zone_id(&self) -> std::option::Option<&str> {
self.hosted_zone_id.as_deref()
}
}
pub mod domain_name_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) domain_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) certificate_arn: std::option::Option<std::string::String>,
pub(crate) appsync_domain_name: std::option::Option<std::string::String>,
pub(crate) hosted_zone_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn domain_name(mut self, input: impl Into<std::string::String>) -> Self {
self.domain_name = Some(input.into());
self
}
pub fn set_domain_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.domain_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 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 appsync_domain_name(mut self, input: impl Into<std::string::String>) -> Self {
self.appsync_domain_name = Some(input.into());
self
}
pub fn set_appsync_domain_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.appsync_domain_name = input;
self
}
pub fn hosted_zone_id(mut self, input: impl Into<std::string::String>) -> Self {
self.hosted_zone_id = Some(input.into());
self
}
pub fn set_hosted_zone_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.hosted_zone_id = input;
self
}
pub fn build(self) -> crate::model::DomainNameConfig {
crate::model::DomainNameConfig {
domain_name: self.domain_name,
description: self.description,
certificate_arn: self.certificate_arn,
appsync_domain_name: self.appsync_domain_name,
hosted_zone_id: self.hosted_zone_id,
}
}
}
}
impl DomainNameConfig {
pub fn builder() -> crate::model::domain_name_config::Builder {
crate::model::domain_name_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DataSource {
#[doc(hidden)]
pub data_source_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
#[doc(hidden)]
pub r#type: std::option::Option<crate::model::DataSourceType>,
#[doc(hidden)]
pub service_role_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub dynamodb_config: std::option::Option<crate::model::DynamodbDataSourceConfig>,
#[doc(hidden)]
pub lambda_config: std::option::Option<crate::model::LambdaDataSourceConfig>,
#[doc(hidden)]
pub elasticsearch_config: std::option::Option<crate::model::ElasticsearchDataSourceConfig>,
#[doc(hidden)]
pub open_search_service_config:
std::option::Option<crate::model::OpenSearchServiceDataSourceConfig>,
#[doc(hidden)]
pub http_config: std::option::Option<crate::model::HttpDataSourceConfig>,
#[doc(hidden)]
pub relational_database_config:
std::option::Option<crate::model::RelationalDatabaseDataSourceConfig>,
}
impl DataSource {
pub fn data_source_arn(&self) -> std::option::Option<&str> {
self.data_source_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 r#type(&self) -> std::option::Option<&crate::model::DataSourceType> {
self.r#type.as_ref()
}
pub fn service_role_arn(&self) -> std::option::Option<&str> {
self.service_role_arn.as_deref()
}
pub fn dynamodb_config(&self) -> std::option::Option<&crate::model::DynamodbDataSourceConfig> {
self.dynamodb_config.as_ref()
}
pub fn lambda_config(&self) -> std::option::Option<&crate::model::LambdaDataSourceConfig> {
self.lambda_config.as_ref()
}
pub fn elasticsearch_config(
&self,
) -> std::option::Option<&crate::model::ElasticsearchDataSourceConfig> {
self.elasticsearch_config.as_ref()
}
pub fn open_search_service_config(
&self,
) -> std::option::Option<&crate::model::OpenSearchServiceDataSourceConfig> {
self.open_search_service_config.as_ref()
}
pub fn http_config(&self) -> std::option::Option<&crate::model::HttpDataSourceConfig> {
self.http_config.as_ref()
}
pub fn relational_database_config(
&self,
) -> std::option::Option<&crate::model::RelationalDatabaseDataSourceConfig> {
self.relational_database_config.as_ref()
}
}
pub mod data_source {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) data_source_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) r#type: std::option::Option<crate::model::DataSourceType>,
pub(crate) service_role_arn: std::option::Option<std::string::String>,
pub(crate) dynamodb_config: std::option::Option<crate::model::DynamodbDataSourceConfig>,
pub(crate) lambda_config: std::option::Option<crate::model::LambdaDataSourceConfig>,
pub(crate) elasticsearch_config:
std::option::Option<crate::model::ElasticsearchDataSourceConfig>,
pub(crate) open_search_service_config:
std::option::Option<crate::model::OpenSearchServiceDataSourceConfig>,
pub(crate) http_config: std::option::Option<crate::model::HttpDataSourceConfig>,
pub(crate) relational_database_config:
std::option::Option<crate::model::RelationalDatabaseDataSourceConfig>,
}
impl Builder {
pub fn data_source_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.data_source_arn = Some(input.into());
self
}
pub fn set_data_source_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.data_source_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 r#type(mut self, input: crate::model::DataSourceType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(
mut self,
input: std::option::Option<crate::model::DataSourceType>,
) -> Self {
self.r#type = input;
self
}
pub fn service_role_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.service_role_arn = Some(input.into());
self
}
pub fn set_service_role_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.service_role_arn = input;
self
}
pub fn dynamodb_config(mut self, input: crate::model::DynamodbDataSourceConfig) -> Self {
self.dynamodb_config = Some(input);
self
}
pub fn set_dynamodb_config(
mut self,
input: std::option::Option<crate::model::DynamodbDataSourceConfig>,
) -> Self {
self.dynamodb_config = input;
self
}
pub fn lambda_config(mut self, input: crate::model::LambdaDataSourceConfig) -> Self {
self.lambda_config = Some(input);
self
}
pub fn set_lambda_config(
mut self,
input: std::option::Option<crate::model::LambdaDataSourceConfig>,
) -> Self {
self.lambda_config = input;
self
}
pub fn elasticsearch_config(
mut self,
input: crate::model::ElasticsearchDataSourceConfig,
) -> Self {
self.elasticsearch_config = Some(input);
self
}
pub fn set_elasticsearch_config(
mut self,
input: std::option::Option<crate::model::ElasticsearchDataSourceConfig>,
) -> Self {
self.elasticsearch_config = input;
self
}
pub fn open_search_service_config(
mut self,
input: crate::model::OpenSearchServiceDataSourceConfig,
) -> Self {
self.open_search_service_config = Some(input);
self
}
pub fn set_open_search_service_config(
mut self,
input: std::option::Option<crate::model::OpenSearchServiceDataSourceConfig>,
) -> Self {
self.open_search_service_config = input;
self
}
pub fn http_config(mut self, input: crate::model::HttpDataSourceConfig) -> Self {
self.http_config = Some(input);
self
}
pub fn set_http_config(
mut self,
input: std::option::Option<crate::model::HttpDataSourceConfig>,
) -> Self {
self.http_config = input;
self
}
pub fn relational_database_config(
mut self,
input: crate::model::RelationalDatabaseDataSourceConfig,
) -> Self {
self.relational_database_config = Some(input);
self
}
pub fn set_relational_database_config(
mut self,
input: std::option::Option<crate::model::RelationalDatabaseDataSourceConfig>,
) -> Self {
self.relational_database_config = input;
self
}
pub fn build(self) -> crate::model::DataSource {
crate::model::DataSource {
data_source_arn: self.data_source_arn,
name: self.name,
description: self.description,
r#type: self.r#type,
service_role_arn: self.service_role_arn,
dynamodb_config: self.dynamodb_config,
lambda_config: self.lambda_config,
elasticsearch_config: self.elasticsearch_config,
open_search_service_config: self.open_search_service_config,
http_config: self.http_config,
relational_database_config: self.relational_database_config,
}
}
}
}
impl DataSource {
pub fn builder() -> crate::model::data_source::Builder {
crate::model::data_source::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RelationalDatabaseDataSourceConfig {
#[doc(hidden)]
pub relational_database_source_type:
std::option::Option<crate::model::RelationalDatabaseSourceType>,
#[doc(hidden)]
pub rds_http_endpoint_config: std::option::Option<crate::model::RdsHttpEndpointConfig>,
}
impl RelationalDatabaseDataSourceConfig {
pub fn relational_database_source_type(
&self,
) -> std::option::Option<&crate::model::RelationalDatabaseSourceType> {
self.relational_database_source_type.as_ref()
}
pub fn rds_http_endpoint_config(
&self,
) -> std::option::Option<&crate::model::RdsHttpEndpointConfig> {
self.rds_http_endpoint_config.as_ref()
}
}
pub mod relational_database_data_source_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) relational_database_source_type:
std::option::Option<crate::model::RelationalDatabaseSourceType>,
pub(crate) rds_http_endpoint_config:
std::option::Option<crate::model::RdsHttpEndpointConfig>,
}
impl Builder {
pub fn relational_database_source_type(
mut self,
input: crate::model::RelationalDatabaseSourceType,
) -> Self {
self.relational_database_source_type = Some(input);
self
}
pub fn set_relational_database_source_type(
mut self,
input: std::option::Option<crate::model::RelationalDatabaseSourceType>,
) -> Self {
self.relational_database_source_type = input;
self
}
pub fn rds_http_endpoint_config(
mut self,
input: crate::model::RdsHttpEndpointConfig,
) -> Self {
self.rds_http_endpoint_config = Some(input);
self
}
pub fn set_rds_http_endpoint_config(
mut self,
input: std::option::Option<crate::model::RdsHttpEndpointConfig>,
) -> Self {
self.rds_http_endpoint_config = input;
self
}
pub fn build(self) -> crate::model::RelationalDatabaseDataSourceConfig {
crate::model::RelationalDatabaseDataSourceConfig {
relational_database_source_type: self.relational_database_source_type,
rds_http_endpoint_config: self.rds_http_endpoint_config,
}
}
}
}
impl RelationalDatabaseDataSourceConfig {
pub fn builder() -> crate::model::relational_database_data_source_config::Builder {
crate::model::relational_database_data_source_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RdsHttpEndpointConfig {
#[doc(hidden)]
pub aws_region: std::option::Option<std::string::String>,
#[doc(hidden)]
pub db_cluster_identifier: std::option::Option<std::string::String>,
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub schema: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aws_secret_store_arn: std::option::Option<std::string::String>,
}
impl RdsHttpEndpointConfig {
pub fn aws_region(&self) -> std::option::Option<&str> {
self.aws_region.as_deref()
}
pub fn db_cluster_identifier(&self) -> std::option::Option<&str> {
self.db_cluster_identifier.as_deref()
}
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
pub fn schema(&self) -> std::option::Option<&str> {
self.schema.as_deref()
}
pub fn aws_secret_store_arn(&self) -> std::option::Option<&str> {
self.aws_secret_store_arn.as_deref()
}
}
pub mod rds_http_endpoint_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) aws_region: std::option::Option<std::string::String>,
pub(crate) db_cluster_identifier: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) schema: std::option::Option<std::string::String>,
pub(crate) aws_secret_store_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn aws_region(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_region = Some(input.into());
self
}
pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
self.aws_region = input;
self
}
pub fn db_cluster_identifier(mut self, input: impl Into<std::string::String>) -> Self {
self.db_cluster_identifier = Some(input.into());
self
}
pub fn set_db_cluster_identifier(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.db_cluster_identifier = input;
self
}
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
pub fn schema(mut self, input: impl Into<std::string::String>) -> Self {
self.schema = Some(input.into());
self
}
pub fn set_schema(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schema = input;
self
}
pub fn aws_secret_store_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_secret_store_arn = Some(input.into());
self
}
pub fn set_aws_secret_store_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.aws_secret_store_arn = input;
self
}
pub fn build(self) -> crate::model::RdsHttpEndpointConfig {
crate::model::RdsHttpEndpointConfig {
aws_region: self.aws_region,
db_cluster_identifier: self.db_cluster_identifier,
database_name: self.database_name,
schema: self.schema,
aws_secret_store_arn: self.aws_secret_store_arn,
}
}
}
}
impl RdsHttpEndpointConfig {
pub fn builder() -> crate::model::rds_http_endpoint_config::Builder {
crate::model::rds_http_endpoint_config::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 RelationalDatabaseSourceType {
#[allow(missing_docs)] RdsHttpEndpoint,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for RelationalDatabaseSourceType {
fn from(s: &str) -> Self {
match s {
"RDS_HTTP_ENDPOINT" => RelationalDatabaseSourceType::RdsHttpEndpoint,
other => RelationalDatabaseSourceType::Unknown(crate::types::UnknownVariantValue(
other.to_owned(),
)),
}
}
}
impl std::str::FromStr for RelationalDatabaseSourceType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(RelationalDatabaseSourceType::from(s))
}
}
impl RelationalDatabaseSourceType {
pub fn as_str(&self) -> &str {
match self {
RelationalDatabaseSourceType::RdsHttpEndpoint => "RDS_HTTP_ENDPOINT",
RelationalDatabaseSourceType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["RDS_HTTP_ENDPOINT"]
}
}
impl AsRef<str> for RelationalDatabaseSourceType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct HttpDataSourceConfig {
#[doc(hidden)]
pub endpoint: std::option::Option<std::string::String>,
#[doc(hidden)]
pub authorization_config: std::option::Option<crate::model::AuthorizationConfig>,
}
impl HttpDataSourceConfig {
pub fn endpoint(&self) -> std::option::Option<&str> {
self.endpoint.as_deref()
}
pub fn authorization_config(&self) -> std::option::Option<&crate::model::AuthorizationConfig> {
self.authorization_config.as_ref()
}
}
pub mod http_data_source_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint: std::option::Option<std::string::String>,
pub(crate) authorization_config: std::option::Option<crate::model::AuthorizationConfig>,
}
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 authorization_config(mut self, input: crate::model::AuthorizationConfig) -> Self {
self.authorization_config = Some(input);
self
}
pub fn set_authorization_config(
mut self,
input: std::option::Option<crate::model::AuthorizationConfig>,
) -> Self {
self.authorization_config = input;
self
}
pub fn build(self) -> crate::model::HttpDataSourceConfig {
crate::model::HttpDataSourceConfig {
endpoint: self.endpoint,
authorization_config: self.authorization_config,
}
}
}
}
impl HttpDataSourceConfig {
pub fn builder() -> crate::model::http_data_source_config::Builder {
crate::model::http_data_source_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AuthorizationConfig {
#[doc(hidden)]
pub authorization_type: std::option::Option<crate::model::AuthorizationType>,
#[doc(hidden)]
pub aws_iam_config: std::option::Option<crate::model::AwsIamConfig>,
}
impl AuthorizationConfig {
pub fn authorization_type(&self) -> std::option::Option<&crate::model::AuthorizationType> {
self.authorization_type.as_ref()
}
pub fn aws_iam_config(&self) -> std::option::Option<&crate::model::AwsIamConfig> {
self.aws_iam_config.as_ref()
}
}
pub mod authorization_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) authorization_type: std::option::Option<crate::model::AuthorizationType>,
pub(crate) aws_iam_config: std::option::Option<crate::model::AwsIamConfig>,
}
impl Builder {
pub fn authorization_type(mut self, input: crate::model::AuthorizationType) -> Self {
self.authorization_type = Some(input);
self
}
pub fn set_authorization_type(
mut self,
input: std::option::Option<crate::model::AuthorizationType>,
) -> Self {
self.authorization_type = input;
self
}
pub fn aws_iam_config(mut self, input: crate::model::AwsIamConfig) -> Self {
self.aws_iam_config = Some(input);
self
}
pub fn set_aws_iam_config(
mut self,
input: std::option::Option<crate::model::AwsIamConfig>,
) -> Self {
self.aws_iam_config = input;
self
}
pub fn build(self) -> crate::model::AuthorizationConfig {
crate::model::AuthorizationConfig {
authorization_type: self.authorization_type,
aws_iam_config: self.aws_iam_config,
}
}
}
}
impl AuthorizationConfig {
pub fn builder() -> crate::model::authorization_config::Builder {
crate::model::authorization_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AwsIamConfig {
#[doc(hidden)]
pub signing_region: std::option::Option<std::string::String>,
#[doc(hidden)]
pub signing_service_name: std::option::Option<std::string::String>,
}
impl AwsIamConfig {
pub fn signing_region(&self) -> std::option::Option<&str> {
self.signing_region.as_deref()
}
pub fn signing_service_name(&self) -> std::option::Option<&str> {
self.signing_service_name.as_deref()
}
}
pub mod aws_iam_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) signing_region: std::option::Option<std::string::String>,
pub(crate) signing_service_name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn signing_region(mut self, input: impl Into<std::string::String>) -> Self {
self.signing_region = Some(input.into());
self
}
pub fn set_signing_region(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.signing_region = input;
self
}
pub fn signing_service_name(mut self, input: impl Into<std::string::String>) -> Self {
self.signing_service_name = Some(input.into());
self
}
pub fn set_signing_service_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.signing_service_name = input;
self
}
pub fn build(self) -> crate::model::AwsIamConfig {
crate::model::AwsIamConfig {
signing_region: self.signing_region,
signing_service_name: self.signing_service_name,
}
}
}
}
impl AwsIamConfig {
pub fn builder() -> crate::model::aws_iam_config::Builder {
crate::model::aws_iam_config::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 AuthorizationType {
#[allow(missing_docs)] AwsIam,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for AuthorizationType {
fn from(s: &str) -> Self {
match s {
"AWS_IAM" => AuthorizationType::AwsIam,
other => {
AuthorizationType::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for AuthorizationType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(AuthorizationType::from(s))
}
}
impl AuthorizationType {
pub fn as_str(&self) -> &str {
match self {
AuthorizationType::AwsIam => "AWS_IAM",
AuthorizationType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["AWS_IAM"]
}
}
impl AsRef<str> for AuthorizationType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct OpenSearchServiceDataSourceConfig {
#[doc(hidden)]
pub endpoint: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aws_region: std::option::Option<std::string::String>,
}
impl OpenSearchServiceDataSourceConfig {
pub fn endpoint(&self) -> std::option::Option<&str> {
self.endpoint.as_deref()
}
pub fn aws_region(&self) -> std::option::Option<&str> {
self.aws_region.as_deref()
}
}
pub mod open_search_service_data_source_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint: std::option::Option<std::string::String>,
pub(crate) aws_region: std::option::Option<std::string::String>,
}
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 aws_region(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_region = Some(input.into());
self
}
pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
self.aws_region = input;
self
}
pub fn build(self) -> crate::model::OpenSearchServiceDataSourceConfig {
crate::model::OpenSearchServiceDataSourceConfig {
endpoint: self.endpoint,
aws_region: self.aws_region,
}
}
}
}
impl OpenSearchServiceDataSourceConfig {
pub fn builder() -> crate::model::open_search_service_data_source_config::Builder {
crate::model::open_search_service_data_source_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ElasticsearchDataSourceConfig {
#[doc(hidden)]
pub endpoint: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aws_region: std::option::Option<std::string::String>,
}
impl ElasticsearchDataSourceConfig {
pub fn endpoint(&self) -> std::option::Option<&str> {
self.endpoint.as_deref()
}
pub fn aws_region(&self) -> std::option::Option<&str> {
self.aws_region.as_deref()
}
}
pub mod elasticsearch_data_source_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint: std::option::Option<std::string::String>,
pub(crate) aws_region: std::option::Option<std::string::String>,
}
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 aws_region(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_region = Some(input.into());
self
}
pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
self.aws_region = input;
self
}
pub fn build(self) -> crate::model::ElasticsearchDataSourceConfig {
crate::model::ElasticsearchDataSourceConfig {
endpoint: self.endpoint,
aws_region: self.aws_region,
}
}
}
}
impl ElasticsearchDataSourceConfig {
pub fn builder() -> crate::model::elasticsearch_data_source_config::Builder {
crate::model::elasticsearch_data_source_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LambdaDataSourceConfig {
#[doc(hidden)]
pub lambda_function_arn: std::option::Option<std::string::String>,
}
impl LambdaDataSourceConfig {
pub fn lambda_function_arn(&self) -> std::option::Option<&str> {
self.lambda_function_arn.as_deref()
}
}
pub mod lambda_data_source_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) lambda_function_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn lambda_function_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.lambda_function_arn = Some(input.into());
self
}
pub fn set_lambda_function_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.lambda_function_arn = input;
self
}
pub fn build(self) -> crate::model::LambdaDataSourceConfig {
crate::model::LambdaDataSourceConfig {
lambda_function_arn: self.lambda_function_arn,
}
}
}
}
impl LambdaDataSourceConfig {
pub fn builder() -> crate::model::lambda_data_source_config::Builder {
crate::model::lambda_data_source_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DynamodbDataSourceConfig {
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aws_region: std::option::Option<std::string::String>,
#[doc(hidden)]
pub use_caller_credentials: bool,
#[doc(hidden)]
pub delta_sync_config: std::option::Option<crate::model::DeltaSyncConfig>,
#[doc(hidden)]
pub versioned: bool,
}
impl DynamodbDataSourceConfig {
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
pub fn aws_region(&self) -> std::option::Option<&str> {
self.aws_region.as_deref()
}
pub fn use_caller_credentials(&self) -> bool {
self.use_caller_credentials
}
pub fn delta_sync_config(&self) -> std::option::Option<&crate::model::DeltaSyncConfig> {
self.delta_sync_config.as_ref()
}
pub fn versioned(&self) -> bool {
self.versioned
}
}
pub mod dynamodb_data_source_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) aws_region: std::option::Option<std::string::String>,
pub(crate) use_caller_credentials: std::option::Option<bool>,
pub(crate) delta_sync_config: std::option::Option<crate::model::DeltaSyncConfig>,
pub(crate) versioned: std::option::Option<bool>,
}
impl Builder {
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
pub fn aws_region(mut self, input: impl Into<std::string::String>) -> Self {
self.aws_region = Some(input.into());
self
}
pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
self.aws_region = input;
self
}
pub fn use_caller_credentials(mut self, input: bool) -> Self {
self.use_caller_credentials = Some(input);
self
}
pub fn set_use_caller_credentials(mut self, input: std::option::Option<bool>) -> Self {
self.use_caller_credentials = input;
self
}
pub fn delta_sync_config(mut self, input: crate::model::DeltaSyncConfig) -> Self {
self.delta_sync_config = Some(input);
self
}
pub fn set_delta_sync_config(
mut self,
input: std::option::Option<crate::model::DeltaSyncConfig>,
) -> Self {
self.delta_sync_config = input;
self
}
pub fn versioned(mut self, input: bool) -> Self {
self.versioned = Some(input);
self
}
pub fn set_versioned(mut self, input: std::option::Option<bool>) -> Self {
self.versioned = input;
self
}
pub fn build(self) -> crate::model::DynamodbDataSourceConfig {
crate::model::DynamodbDataSourceConfig {
table_name: self.table_name,
aws_region: self.aws_region,
use_caller_credentials: self.use_caller_credentials.unwrap_or_default(),
delta_sync_config: self.delta_sync_config,
versioned: self.versioned.unwrap_or_default(),
}
}
}
}
impl DynamodbDataSourceConfig {
pub fn builder() -> crate::model::dynamodb_data_source_config::Builder {
crate::model::dynamodb_data_source_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeltaSyncConfig {
#[doc(hidden)]
pub base_table_ttl: i64,
#[doc(hidden)]
pub delta_sync_table_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub delta_sync_table_ttl: i64,
}
impl DeltaSyncConfig {
pub fn base_table_ttl(&self) -> i64 {
self.base_table_ttl
}
pub fn delta_sync_table_name(&self) -> std::option::Option<&str> {
self.delta_sync_table_name.as_deref()
}
pub fn delta_sync_table_ttl(&self) -> i64 {
self.delta_sync_table_ttl
}
}
pub mod delta_sync_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) base_table_ttl: std::option::Option<i64>,
pub(crate) delta_sync_table_name: std::option::Option<std::string::String>,
pub(crate) delta_sync_table_ttl: std::option::Option<i64>,
}
impl Builder {
pub fn base_table_ttl(mut self, input: i64) -> Self {
self.base_table_ttl = Some(input);
self
}
pub fn set_base_table_ttl(mut self, input: std::option::Option<i64>) -> Self {
self.base_table_ttl = input;
self
}
pub fn delta_sync_table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.delta_sync_table_name = Some(input.into());
self
}
pub fn set_delta_sync_table_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.delta_sync_table_name = input;
self
}
pub fn delta_sync_table_ttl(mut self, input: i64) -> Self {
self.delta_sync_table_ttl = Some(input);
self
}
pub fn set_delta_sync_table_ttl(mut self, input: std::option::Option<i64>) -> Self {
self.delta_sync_table_ttl = input;
self
}
pub fn build(self) -> crate::model::DeltaSyncConfig {
crate::model::DeltaSyncConfig {
base_table_ttl: self.base_table_ttl.unwrap_or_default(),
delta_sync_table_name: self.delta_sync_table_name,
delta_sync_table_ttl: self.delta_sync_table_ttl.unwrap_or_default(),
}
}
}
}
impl DeltaSyncConfig {
pub fn builder() -> crate::model::delta_sync_config::Builder {
crate::model::delta_sync_config::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 DataSourceType {
#[allow(missing_docs)] AmazonDynamodb,
#[allow(missing_docs)] AmazonElasticsearch,
#[allow(missing_docs)] AmazonOpensearchService,
#[allow(missing_docs)] AwsLambda,
#[allow(missing_docs)] Http,
#[allow(missing_docs)] None,
#[allow(missing_docs)] RelationalDatabase,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for DataSourceType {
fn from(s: &str) -> Self {
match s {
"AMAZON_DYNAMODB" => DataSourceType::AmazonDynamodb,
"AMAZON_ELASTICSEARCH" => DataSourceType::AmazonElasticsearch,
"AMAZON_OPENSEARCH_SERVICE" => DataSourceType::AmazonOpensearchService,
"AWS_LAMBDA" => DataSourceType::AwsLambda,
"HTTP" => DataSourceType::Http,
"NONE" => DataSourceType::None,
"RELATIONAL_DATABASE" => DataSourceType::RelationalDatabase,
other => DataSourceType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for DataSourceType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DataSourceType::from(s))
}
}
impl DataSourceType {
pub fn as_str(&self) -> &str {
match self {
DataSourceType::AmazonDynamodb => "AMAZON_DYNAMODB",
DataSourceType::AmazonElasticsearch => "AMAZON_ELASTICSEARCH",
DataSourceType::AmazonOpensearchService => "AMAZON_OPENSEARCH_SERVICE",
DataSourceType::AwsLambda => "AWS_LAMBDA",
DataSourceType::Http => "HTTP",
DataSourceType::None => "NONE",
DataSourceType::RelationalDatabase => "RELATIONAL_DATABASE",
DataSourceType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"AMAZON_DYNAMODB",
"AMAZON_ELASTICSEARCH",
"AMAZON_OPENSEARCH_SERVICE",
"AWS_LAMBDA",
"HTTP",
"NONE",
"RELATIONAL_DATABASE",
]
}
}
impl AsRef<str> for DataSourceType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ApiKey {
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
#[doc(hidden)]
pub expires: i64,
#[doc(hidden)]
pub deletes: i64,
}
impl ApiKey {
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn expires(&self) -> i64 {
self.expires
}
pub fn deletes(&self) -> i64 {
self.deletes
}
}
pub mod api_key {
#[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) description: std::option::Option<std::string::String>,
pub(crate) expires: std::option::Option<i64>,
pub(crate) deletes: std::option::Option<i64>,
}
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 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 expires(mut self, input: i64) -> Self {
self.expires = Some(input);
self
}
pub fn set_expires(mut self, input: std::option::Option<i64>) -> Self {
self.expires = input;
self
}
pub fn deletes(mut self, input: i64) -> Self {
self.deletes = Some(input);
self
}
pub fn set_deletes(mut self, input: std::option::Option<i64>) -> Self {
self.deletes = input;
self
}
pub fn build(self) -> crate::model::ApiKey {
crate::model::ApiKey {
id: self.id,
description: self.description,
expires: self.expires.unwrap_or_default(),
deletes: self.deletes.unwrap_or_default(),
}
}
}
}
impl ApiKey {
pub fn builder() -> crate::model::api_key::Builder {
crate::model::api_key::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ApiCache {
#[doc(hidden)]
pub ttl: i64,
#[doc(hidden)]
pub api_caching_behavior: std::option::Option<crate::model::ApiCachingBehavior>,
#[doc(hidden)]
pub transit_encryption_enabled: bool,
#[doc(hidden)]
pub at_rest_encryption_enabled: bool,
#[doc(hidden)]
pub r#type: std::option::Option<crate::model::ApiCacheType>,
#[doc(hidden)]
pub status: std::option::Option<crate::model::ApiCacheStatus>,
}
impl ApiCache {
pub fn ttl(&self) -> i64 {
self.ttl
}
pub fn api_caching_behavior(&self) -> std::option::Option<&crate::model::ApiCachingBehavior> {
self.api_caching_behavior.as_ref()
}
pub fn transit_encryption_enabled(&self) -> bool {
self.transit_encryption_enabled
}
pub fn at_rest_encryption_enabled(&self) -> bool {
self.at_rest_encryption_enabled
}
pub fn r#type(&self) -> std::option::Option<&crate::model::ApiCacheType> {
self.r#type.as_ref()
}
pub fn status(&self) -> std::option::Option<&crate::model::ApiCacheStatus> {
self.status.as_ref()
}
}
pub mod api_cache {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) ttl: std::option::Option<i64>,
pub(crate) api_caching_behavior: std::option::Option<crate::model::ApiCachingBehavior>,
pub(crate) transit_encryption_enabled: std::option::Option<bool>,
pub(crate) at_rest_encryption_enabled: std::option::Option<bool>,
pub(crate) r#type: std::option::Option<crate::model::ApiCacheType>,
pub(crate) status: std::option::Option<crate::model::ApiCacheStatus>,
}
impl Builder {
pub fn ttl(mut self, input: i64) -> Self {
self.ttl = Some(input);
self
}
pub fn set_ttl(mut self, input: std::option::Option<i64>) -> Self {
self.ttl = input;
self
}
pub fn api_caching_behavior(mut self, input: crate::model::ApiCachingBehavior) -> Self {
self.api_caching_behavior = Some(input);
self
}
pub fn set_api_caching_behavior(
mut self,
input: std::option::Option<crate::model::ApiCachingBehavior>,
) -> Self {
self.api_caching_behavior = input;
self
}
pub fn transit_encryption_enabled(mut self, input: bool) -> Self {
self.transit_encryption_enabled = Some(input);
self
}
pub fn set_transit_encryption_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.transit_encryption_enabled = input;
self
}
pub fn at_rest_encryption_enabled(mut self, input: bool) -> Self {
self.at_rest_encryption_enabled = Some(input);
self
}
pub fn set_at_rest_encryption_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.at_rest_encryption_enabled = input;
self
}
pub fn r#type(mut self, input: crate::model::ApiCacheType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(mut self, input: std::option::Option<crate::model::ApiCacheType>) -> Self {
self.r#type = input;
self
}
pub fn status(mut self, input: crate::model::ApiCacheStatus) -> Self {
self.status = Some(input);
self
}
pub fn set_status(
mut self,
input: std::option::Option<crate::model::ApiCacheStatus>,
) -> Self {
self.status = input;
self
}
pub fn build(self) -> crate::model::ApiCache {
crate::model::ApiCache {
ttl: self.ttl.unwrap_or_default(),
api_caching_behavior: self.api_caching_behavior,
transit_encryption_enabled: self.transit_encryption_enabled.unwrap_or_default(),
at_rest_encryption_enabled: self.at_rest_encryption_enabled.unwrap_or_default(),
r#type: self.r#type,
status: self.status,
}
}
}
}
impl ApiCache {
pub fn builder() -> crate::model::api_cache::Builder {
crate::model::api_cache::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 ApiCacheStatus {
#[allow(missing_docs)] Available,
#[allow(missing_docs)] Creating,
#[allow(missing_docs)] Deleting,
#[allow(missing_docs)] Failed,
#[allow(missing_docs)] Modifying,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ApiCacheStatus {
fn from(s: &str) -> Self {
match s {
"AVAILABLE" => ApiCacheStatus::Available,
"CREATING" => ApiCacheStatus::Creating,
"DELETING" => ApiCacheStatus::Deleting,
"FAILED" => ApiCacheStatus::Failed,
"MODIFYING" => ApiCacheStatus::Modifying,
other => ApiCacheStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for ApiCacheStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ApiCacheStatus::from(s))
}
}
impl ApiCacheStatus {
pub fn as_str(&self) -> &str {
match self {
ApiCacheStatus::Available => "AVAILABLE",
ApiCacheStatus::Creating => "CREATING",
ApiCacheStatus::Deleting => "DELETING",
ApiCacheStatus::Failed => "FAILED",
ApiCacheStatus::Modifying => "MODIFYING",
ApiCacheStatus::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["AVAILABLE", "CREATING", "DELETING", "FAILED", "MODIFYING"]
}
}
impl AsRef<str> for ApiCacheStatus {
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 ApiCacheType {
#[allow(missing_docs)] Large,
#[allow(missing_docs)] Large12X,
#[allow(missing_docs)] Large2X,
#[allow(missing_docs)] Large4X,
#[allow(missing_docs)] Large8X,
#[allow(missing_docs)] Medium,
#[allow(missing_docs)] R42Xlarge,
#[allow(missing_docs)] R44Xlarge,
#[allow(missing_docs)] R48Xlarge,
#[allow(missing_docs)] R4Large,
#[allow(missing_docs)] R4Xlarge,
#[allow(missing_docs)] Small,
#[allow(missing_docs)] T2Medium,
#[allow(missing_docs)] T2Small,
#[allow(missing_docs)] Xlarge,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ApiCacheType {
fn from(s: &str) -> Self {
match s {
"LARGE" => ApiCacheType::Large,
"LARGE_12X" => ApiCacheType::Large12X,
"LARGE_2X" => ApiCacheType::Large2X,
"LARGE_4X" => ApiCacheType::Large4X,
"LARGE_8X" => ApiCacheType::Large8X,
"MEDIUM" => ApiCacheType::Medium,
"R4_2XLARGE" => ApiCacheType::R42Xlarge,
"R4_4XLARGE" => ApiCacheType::R44Xlarge,
"R4_8XLARGE" => ApiCacheType::R48Xlarge,
"R4_LARGE" => ApiCacheType::R4Large,
"R4_XLARGE" => ApiCacheType::R4Xlarge,
"SMALL" => ApiCacheType::Small,
"T2_MEDIUM" => ApiCacheType::T2Medium,
"T2_SMALL" => ApiCacheType::T2Small,
"XLARGE" => ApiCacheType::Xlarge,
other => ApiCacheType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for ApiCacheType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ApiCacheType::from(s))
}
}
impl ApiCacheType {
pub fn as_str(&self) -> &str {
match self {
ApiCacheType::Large => "LARGE",
ApiCacheType::Large12X => "LARGE_12X",
ApiCacheType::Large2X => "LARGE_2X",
ApiCacheType::Large4X => "LARGE_4X",
ApiCacheType::Large8X => "LARGE_8X",
ApiCacheType::Medium => "MEDIUM",
ApiCacheType::R42Xlarge => "R4_2XLARGE",
ApiCacheType::R44Xlarge => "R4_4XLARGE",
ApiCacheType::R48Xlarge => "R4_8XLARGE",
ApiCacheType::R4Large => "R4_LARGE",
ApiCacheType::R4Xlarge => "R4_XLARGE",
ApiCacheType::Small => "SMALL",
ApiCacheType::T2Medium => "T2_MEDIUM",
ApiCacheType::T2Small => "T2_SMALL",
ApiCacheType::Xlarge => "XLARGE",
ApiCacheType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"LARGE",
"LARGE_12X",
"LARGE_2X",
"LARGE_4X",
"LARGE_8X",
"MEDIUM",
"R4_2XLARGE",
"R4_4XLARGE",
"R4_8XLARGE",
"R4_LARGE",
"R4_XLARGE",
"SMALL",
"T2_MEDIUM",
"T2_SMALL",
"XLARGE",
]
}
}
impl AsRef<str> for ApiCacheType {
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 ApiCachingBehavior {
#[allow(missing_docs)] FullRequestCaching,
#[allow(missing_docs)] PerResolverCaching,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ApiCachingBehavior {
fn from(s: &str) -> Self {
match s {
"FULL_REQUEST_CACHING" => ApiCachingBehavior::FullRequestCaching,
"PER_RESOLVER_CACHING" => ApiCachingBehavior::PerResolverCaching,
other => {
ApiCachingBehavior::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for ApiCachingBehavior {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ApiCachingBehavior::from(s))
}
}
impl ApiCachingBehavior {
pub fn as_str(&self) -> &str {
match self {
ApiCachingBehavior::FullRequestCaching => "FULL_REQUEST_CACHING",
ApiCachingBehavior::PerResolverCaching => "PER_RESOLVER_CACHING",
ApiCachingBehavior::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["FULL_REQUEST_CACHING", "PER_RESOLVER_CACHING"]
}
}
impl AsRef<str> for ApiCachingBehavior {
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 SchemaStatus {
#[allow(missing_docs)] Active,
#[allow(missing_docs)] Deleting,
#[allow(missing_docs)] Failed,
#[allow(missing_docs)] NotApplicable,
#[allow(missing_docs)] Processing,
#[allow(missing_docs)] Success,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for SchemaStatus {
fn from(s: &str) -> Self {
match s {
"ACTIVE" => SchemaStatus::Active,
"DELETING" => SchemaStatus::Deleting,
"FAILED" => SchemaStatus::Failed,
"NOT_APPLICABLE" => SchemaStatus::NotApplicable,
"PROCESSING" => SchemaStatus::Processing,
"SUCCESS" => SchemaStatus::Success,
other => SchemaStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for SchemaStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SchemaStatus::from(s))
}
}
impl SchemaStatus {
pub fn as_str(&self) -> &str {
match self {
SchemaStatus::Active => "ACTIVE",
SchemaStatus::Deleting => "DELETING",
SchemaStatus::Failed => "FAILED",
SchemaStatus::NotApplicable => "NOT_APPLICABLE",
SchemaStatus::Processing => "PROCESSING",
SchemaStatus::Success => "SUCCESS",
SchemaStatus::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"ACTIVE",
"DELETING",
"FAILED",
"NOT_APPLICABLE",
"PROCESSING",
"SUCCESS",
]
}
}
impl AsRef<str> for SchemaStatus {
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 OutputType {
#[allow(missing_docs)] Json,
#[allow(missing_docs)] Sdl,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for OutputType {
fn from(s: &str) -> Self {
match s {
"JSON" => OutputType::Json,
"SDL" => OutputType::Sdl,
other => OutputType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for OutputType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(OutputType::from(s))
}
}
impl OutputType {
pub fn as_str(&self) -> &str {
match self {
OutputType::Json => "JSON",
OutputType::Sdl => "SDL",
OutputType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["JSON", "SDL"]
}
}
impl AsRef<str> for OutputType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ApiAssociation {
#[doc(hidden)]
pub domain_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub api_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub association_status: std::option::Option<crate::model::AssociationStatus>,
#[doc(hidden)]
pub deployment_detail: std::option::Option<std::string::String>,
}
impl ApiAssociation {
pub fn domain_name(&self) -> std::option::Option<&str> {
self.domain_name.as_deref()
}
pub fn api_id(&self) -> std::option::Option<&str> {
self.api_id.as_deref()
}
pub fn association_status(&self) -> std::option::Option<&crate::model::AssociationStatus> {
self.association_status.as_ref()
}
pub fn deployment_detail(&self) -> std::option::Option<&str> {
self.deployment_detail.as_deref()
}
}
pub mod api_association {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) domain_name: std::option::Option<std::string::String>,
pub(crate) api_id: std::option::Option<std::string::String>,
pub(crate) association_status: std::option::Option<crate::model::AssociationStatus>,
pub(crate) deployment_detail: std::option::Option<std::string::String>,
}
impl Builder {
pub fn domain_name(mut self, input: impl Into<std::string::String>) -> Self {
self.domain_name = Some(input.into());
self
}
pub fn set_domain_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.domain_name = input;
self
}
pub fn api_id(mut self, input: impl Into<std::string::String>) -> Self {
self.api_id = Some(input.into());
self
}
pub fn set_api_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.api_id = input;
self
}
pub fn association_status(mut self, input: crate::model::AssociationStatus) -> Self {
self.association_status = Some(input);
self
}
pub fn set_association_status(
mut self,
input: std::option::Option<crate::model::AssociationStatus>,
) -> Self {
self.association_status = input;
self
}
pub fn deployment_detail(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_detail = Some(input.into());
self
}
pub fn set_deployment_detail(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_detail = input;
self
}
pub fn build(self) -> crate::model::ApiAssociation {
crate::model::ApiAssociation {
domain_name: self.domain_name,
api_id: self.api_id,
association_status: self.association_status,
deployment_detail: self.deployment_detail,
}
}
}
}
impl ApiAssociation {
pub fn builder() -> crate::model::api_association::Builder {
crate::model::api_association::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 AssociationStatus {
#[allow(missing_docs)] Failed,
#[allow(missing_docs)] Processing,
#[allow(missing_docs)] Success,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for AssociationStatus {
fn from(s: &str) -> Self {
match s {
"FAILED" => AssociationStatus::Failed,
"PROCESSING" => AssociationStatus::Processing,
"SUCCESS" => AssociationStatus::Success,
other => {
AssociationStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for AssociationStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(AssociationStatus::from(s))
}
}
impl AssociationStatus {
pub fn as_str(&self) -> &str {
match self {
AssociationStatus::Failed => "FAILED",
AssociationStatus::Processing => "PROCESSING",
AssociationStatus::Success => "SUCCESS",
AssociationStatus::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["FAILED", "PROCESSING", "SUCCESS"]
}
}
impl AsRef<str> for AssociationStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ErrorDetail {
#[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ErrorDetail {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
pub mod error_detail {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::model::ErrorDetail {
crate::model::ErrorDetail {
message: self.message,
}
}
}
}
impl ErrorDetail {
pub fn builder() -> crate::model::error_detail::Builder {
crate::model::error_detail::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct EvaluateCodeErrorDetail {
#[doc(hidden)]
pub message: std::option::Option<std::string::String>,
#[doc(hidden)]
pub code_errors: std::option::Option<std::vec::Vec<crate::model::CodeError>>,
}
impl EvaluateCodeErrorDetail {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
pub fn code_errors(&self) -> std::option::Option<&[crate::model::CodeError]> {
self.code_errors.as_deref()
}
}
pub mod evaluate_code_error_detail {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
pub(crate) code_errors: std::option::Option<std::vec::Vec<crate::model::CodeError>>,
}
impl Builder {
pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn code_errors(mut self, input: crate::model::CodeError) -> Self {
let mut v = self.code_errors.unwrap_or_default();
v.push(input);
self.code_errors = Some(v);
self
}
pub fn set_code_errors(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CodeError>>,
) -> Self {
self.code_errors = input;
self
}
pub fn build(self) -> crate::model::EvaluateCodeErrorDetail {
crate::model::EvaluateCodeErrorDetail {
message: self.message,
code_errors: self.code_errors,
}
}
}
}
impl EvaluateCodeErrorDetail {
pub fn builder() -> crate::model::evaluate_code_error_detail::Builder {
crate::model::evaluate_code_error_detail::Builder::default()
}
}