TableDescription.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/dynamodb/DynamoDB_EXPORTS.h>
#include <aws/dynamodb/model/ArchivalSummary.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/BillingModeSummary.h>
#include <aws/dynamodb/model/GlobalSecondaryIndexDescription.h>
#include <aws/dynamodb/model/GlobalTableSettingsReplicationMode.h>
#include <aws/dynamodb/model/GlobalTableWitnessDescription.h>
#include <aws/dynamodb/model/KeySchemaElement.h>
#include <aws/dynamodb/model/LocalSecondaryIndexDescription.h>
#include <aws/dynamodb/model/MultiRegionConsistency.h>
#include <aws/dynamodb/model/OnDemandThroughput.h>
#include <aws/dynamodb/model/ProvisionedThroughputDescription.h>
#include <aws/dynamodb/model/ReplicaDescription.h>
#include <aws/dynamodb/model/RestoreSummary.h>
#include <aws/dynamodb/model/SSEDescription.h>
#include <aws/dynamodb/model/StreamSpecification.h>
#include <aws/dynamodb/model/TableClassSummary.h>
#include <aws/dynamodb/model/TableStatus.h>
#include <aws/dynamodb/model/TableWarmThroughputDescription.h>
#include <aws/dynamodb/model/VectorIndexDescription.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DynamoDB {
namespace Model {
 
class TableDescription {
 public:
  AWS_DYNAMODB_API TableDescription() = default;
  AWS_DYNAMODB_API TableDescription(Aws::Utils::Json::JsonView jsonValue);
  AWS_DYNAMODB_API TableDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DYNAMODB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<AttributeDefinition>& GetAttributeDefinitions() const { return m_attributeDefinitions; }
  inline bool AttributeDefinitionsHasBeenSet() const { return m_attributeDefinitionsHasBeenSet; }
  template <typename AttributeDefinitionsT = Aws::Vector<AttributeDefinition>>
  void SetAttributeDefinitions(AttributeDefinitionsT&& value) {
    m_attributeDefinitionsHasBeenSet = true;
    m_attributeDefinitions = std::forward<AttributeDefinitionsT>(value);
  }
  template <typename AttributeDefinitionsT = Aws::Vector<AttributeDefinition>>
  TableDescription& WithAttributeDefinitions(AttributeDefinitionsT&& value) {
    SetAttributeDefinitions(std::forward<AttributeDefinitionsT>(value));
    return *this;
  }
  template <typename AttributeDefinitionsT = AttributeDefinition>
  TableDescription& AddAttributeDefinitions(AttributeDefinitionsT&& value) {
    m_attributeDefinitionsHasBeenSet = true;
    m_attributeDefinitions.emplace_back(std::forward<AttributeDefinitionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTableName() const { return m_tableName; }
  inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
  template <typename TableNameT = Aws::String>
  void SetTableName(TableNameT&& value) {
    m_tableNameHasBeenSet = true;
    m_tableName = std::forward<TableNameT>(value);
  }
  template <typename TableNameT = Aws::String>
  TableDescription& WithTableName(TableNameT&& value) {
    SetTableName(std::forward<TableNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<KeySchemaElement>& GetKeySchema() const { return m_keySchema; }
  inline bool KeySchemaHasBeenSet() const { return m_keySchemaHasBeenSet; }
  template <typename KeySchemaT = Aws::Vector<KeySchemaElement>>
  void SetKeySchema(KeySchemaT&& value) {
    m_keySchemaHasBeenSet = true;
    m_keySchema = std::forward<KeySchemaT>(value);
  }
  template <typename KeySchemaT = Aws::Vector<KeySchemaElement>>
  TableDescription& WithKeySchema(KeySchemaT&& value) {
    SetKeySchema(std::forward<KeySchemaT>(value));
    return *this;
  }
  template <typename KeySchemaT = KeySchemaElement>
  TableDescription& AddKeySchema(KeySchemaT&& value) {
    m_keySchemaHasBeenSet = true;
    m_keySchema.emplace_back(std::forward<KeySchemaT>(value));
    return *this;
  }
 
 
  inline TableStatus GetTableStatus() const { return m_tableStatus; }
  inline bool TableStatusHasBeenSet() const { return m_tableStatusHasBeenSet; }
  inline void SetTableStatus(TableStatus value) {
    m_tableStatusHasBeenSet = true;
    m_tableStatus = value;
  }
  inline TableDescription& WithTableStatus(TableStatus value) {
    SetTableStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationDateTime() const { return m_creationDateTime; }
  inline bool CreationDateTimeHasBeenSet() const { return m_creationDateTimeHasBeenSet; }
  template <typename CreationDateTimeT = Aws::Utils::DateTime>
  void SetCreationDateTime(CreationDateTimeT&& value) {
    m_creationDateTimeHasBeenSet = true;
    m_creationDateTime = std::forward<CreationDateTimeT>(value);
  }
  template <typename CreationDateTimeT = Aws::Utils::DateTime>
  TableDescription& WithCreationDateTime(CreationDateTimeT&& value) {
    SetCreationDateTime(std::forward<CreationDateTimeT>(value));
    return *this;
  }
 
 
  inline const ProvisionedThroughputDescription& GetProvisionedThroughput() const { return m_provisionedThroughput; }
  inline bool ProvisionedThroughputHasBeenSet() const { return m_provisionedThroughputHasBeenSet; }
  template <typename ProvisionedThroughputT = ProvisionedThroughputDescription>
  void SetProvisionedThroughput(ProvisionedThroughputT&& value) {
    m_provisionedThroughputHasBeenSet = true;
    m_provisionedThroughput = std::forward<ProvisionedThroughputT>(value);
  }
  template <typename ProvisionedThroughputT = ProvisionedThroughputDescription>
  TableDescription& WithProvisionedThroughput(ProvisionedThroughputT&& value) {
    SetProvisionedThroughput(std::forward<ProvisionedThroughputT>(value));
    return *this;
  }
 
 
  inline long long GetTableSizeBytes() const { return m_tableSizeBytes; }
  inline bool TableSizeBytesHasBeenSet() const { return m_tableSizeBytesHasBeenSet; }
  inline void SetTableSizeBytes(long long value) {
    m_tableSizeBytesHasBeenSet = true;
    m_tableSizeBytes = value;
  }
  inline TableDescription& WithTableSizeBytes(long long value) {
    SetTableSizeBytes(value);
    return *this;
  }
 
 
  inline long long GetItemCount() const { return m_itemCount; }
  inline bool ItemCountHasBeenSet() const { return m_itemCountHasBeenSet; }
  inline void SetItemCount(long long value) {
    m_itemCountHasBeenSet = true;
    m_itemCount = value;
  }
  inline TableDescription& WithItemCount(long long value) {
    SetItemCount(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTableArn() const { return m_tableArn; }
  inline bool TableArnHasBeenSet() const { return m_tableArnHasBeenSet; }
  template <typename TableArnT = Aws::String>
  void SetTableArn(TableArnT&& value) {
    m_tableArnHasBeenSet = true;
    m_tableArn = std::forward<TableArnT>(value);
  }
  template <typename TableArnT = Aws::String>
  TableDescription& WithTableArn(TableArnT&& value) {
    SetTableArn(std::forward<TableArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTableId() const { return m_tableId; }
  inline bool TableIdHasBeenSet() const { return m_tableIdHasBeenSet; }
  template <typename TableIdT = Aws::String>
  void SetTableId(TableIdT&& value) {
    m_tableIdHasBeenSet = true;
    m_tableId = std::forward<TableIdT>(value);
  }
  template <typename TableIdT = Aws::String>
  TableDescription& WithTableId(TableIdT&& value) {
    SetTableId(std::forward<TableIdT>(value));
    return *this;
  }
 
 
  inline const BillingModeSummary& GetBillingModeSummary() const { return m_billingModeSummary; }
  inline bool BillingModeSummaryHasBeenSet() const { return m_billingModeSummaryHasBeenSet; }
  template <typename BillingModeSummaryT = BillingModeSummary>
  void SetBillingModeSummary(BillingModeSummaryT&& value) {
    m_billingModeSummaryHasBeenSet = true;
    m_billingModeSummary = std::forward<BillingModeSummaryT>(value);
  }
  template <typename BillingModeSummaryT = BillingModeSummary>
  TableDescription& WithBillingModeSummary(BillingModeSummaryT&& value) {
    SetBillingModeSummary(std::forward<BillingModeSummaryT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LocalSecondaryIndexDescription>& GetLocalSecondaryIndexes() const { return m_localSecondaryIndexes; }
  inline bool LocalSecondaryIndexesHasBeenSet() const { return m_localSecondaryIndexesHasBeenSet; }
  template <typename LocalSecondaryIndexesT = Aws::Vector<LocalSecondaryIndexDescription>>
  void SetLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) {
    m_localSecondaryIndexesHasBeenSet = true;
    m_localSecondaryIndexes = std::forward<LocalSecondaryIndexesT>(value);
  }
  template <typename LocalSecondaryIndexesT = Aws::Vector<LocalSecondaryIndexDescription>>
  TableDescription& WithLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) {
    SetLocalSecondaryIndexes(std::forward<LocalSecondaryIndexesT>(value));
    return *this;
  }
  template <typename LocalSecondaryIndexesT = LocalSecondaryIndexDescription>
  TableDescription& AddLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) {
    m_localSecondaryIndexesHasBeenSet = true;
    m_localSecondaryIndexes.emplace_back(std::forward<LocalSecondaryIndexesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<GlobalSecondaryIndexDescription>& GetGlobalSecondaryIndexes() const { return m_globalSecondaryIndexes; }
  inline bool GlobalSecondaryIndexesHasBeenSet() const { return m_globalSecondaryIndexesHasBeenSet; }
  template <typename GlobalSecondaryIndexesT = Aws::Vector<GlobalSecondaryIndexDescription>>
  void SetGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) {
    m_globalSecondaryIndexesHasBeenSet = true;
    m_globalSecondaryIndexes = std::forward<GlobalSecondaryIndexesT>(value);
  }
  template <typename GlobalSecondaryIndexesT = Aws::Vector<GlobalSecondaryIndexDescription>>
  TableDescription& WithGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) {
    SetGlobalSecondaryIndexes(std::forward<GlobalSecondaryIndexesT>(value));
    return *this;
  }
  template <typename GlobalSecondaryIndexesT = GlobalSecondaryIndexDescription>
  TableDescription& AddGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) {
    m_globalSecondaryIndexesHasBeenSet = true;
    m_globalSecondaryIndexes.emplace_back(std::forward<GlobalSecondaryIndexesT>(value));
    return *this;
  }
 
 
  inline const StreamSpecification& GetStreamSpecification() const { return m_streamSpecification; }
  inline bool StreamSpecificationHasBeenSet() const { return m_streamSpecificationHasBeenSet; }
  template <typename StreamSpecificationT = StreamSpecification>
  void SetStreamSpecification(StreamSpecificationT&& value) {
    m_streamSpecificationHasBeenSet = true;
    m_streamSpecification = std::forward<StreamSpecificationT>(value);
  }
  template <typename StreamSpecificationT = StreamSpecification>
  TableDescription& WithStreamSpecification(StreamSpecificationT&& value) {
    SetStreamSpecification(std::forward<StreamSpecificationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLatestStreamLabel() const { return m_latestStreamLabel; }
  inline bool LatestStreamLabelHasBeenSet() const { return m_latestStreamLabelHasBeenSet; }
  template <typename LatestStreamLabelT = Aws::String>
  void SetLatestStreamLabel(LatestStreamLabelT&& value) {
    m_latestStreamLabelHasBeenSet = true;
    m_latestStreamLabel = std::forward<LatestStreamLabelT>(value);
  }
  template <typename LatestStreamLabelT = Aws::String>
  TableDescription& WithLatestStreamLabel(LatestStreamLabelT&& value) {
    SetLatestStreamLabel(std::forward<LatestStreamLabelT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLatestStreamArn() const { return m_latestStreamArn; }
  inline bool LatestStreamArnHasBeenSet() const { return m_latestStreamArnHasBeenSet; }
  template <typename LatestStreamArnT = Aws::String>
  void SetLatestStreamArn(LatestStreamArnT&& value) {
    m_latestStreamArnHasBeenSet = true;
    m_latestStreamArn = std::forward<LatestStreamArnT>(value);
  }
  template <typename LatestStreamArnT = Aws::String>
  TableDescription& WithLatestStreamArn(LatestStreamArnT&& value) {
    SetLatestStreamArn(std::forward<LatestStreamArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGlobalTableVersion() const { return m_globalTableVersion; }
  inline bool GlobalTableVersionHasBeenSet() const { return m_globalTableVersionHasBeenSet; }
  template <typename GlobalTableVersionT = Aws::String>
  void SetGlobalTableVersion(GlobalTableVersionT&& value) {
    m_globalTableVersionHasBeenSet = true;
    m_globalTableVersion = std::forward<GlobalTableVersionT>(value);
  }
  template <typename GlobalTableVersionT = Aws::String>
  TableDescription& WithGlobalTableVersion(GlobalTableVersionT&& value) {
    SetGlobalTableVersion(std::forward<GlobalTableVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ReplicaDescription>& GetReplicas() const { return m_replicas; }
  inline bool ReplicasHasBeenSet() const { return m_replicasHasBeenSet; }
  template <typename ReplicasT = Aws::Vector<ReplicaDescription>>
  void SetReplicas(ReplicasT&& value) {
    m_replicasHasBeenSet = true;
    m_replicas = std::forward<ReplicasT>(value);
  }
  template <typename ReplicasT = Aws::Vector<ReplicaDescription>>
  TableDescription& WithReplicas(ReplicasT&& value) {
    SetReplicas(std::forward<ReplicasT>(value));
    return *this;
  }
  template <typename ReplicasT = ReplicaDescription>
  TableDescription& AddReplicas(ReplicasT&& value) {
    m_replicasHasBeenSet = true;
    m_replicas.emplace_back(std::forward<ReplicasT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<GlobalTableWitnessDescription>& GetGlobalTableWitnesses() const { return m_globalTableWitnesses; }
  inline bool GlobalTableWitnessesHasBeenSet() const { return m_globalTableWitnessesHasBeenSet; }
  template <typename GlobalTableWitnessesT = Aws::Vector<GlobalTableWitnessDescription>>
  void SetGlobalTableWitnesses(GlobalTableWitnessesT&& value) {
    m_globalTableWitnessesHasBeenSet = true;
    m_globalTableWitnesses = std::forward<GlobalTableWitnessesT>(value);
  }
  template <typename GlobalTableWitnessesT = Aws::Vector<GlobalTableWitnessDescription>>
  TableDescription& WithGlobalTableWitnesses(GlobalTableWitnessesT&& value) {
    SetGlobalTableWitnesses(std::forward<GlobalTableWitnessesT>(value));
    return *this;
  }
  template <typename GlobalTableWitnessesT = GlobalTableWitnessDescription>
  TableDescription& AddGlobalTableWitnesses(GlobalTableWitnessesT&& value) {
    m_globalTableWitnessesHasBeenSet = true;
    m_globalTableWitnesses.emplace_back(std::forward<GlobalTableWitnessesT>(value));
    return *this;
  }
 
 
  inline GlobalTableSettingsReplicationMode GetGlobalTableSettingsReplicationMode() const { return m_globalTableSettingsReplicationMode; }
  inline bool GlobalTableSettingsReplicationModeHasBeenSet() const { return m_globalTableSettingsReplicationModeHasBeenSet; }
  inline void SetGlobalTableSettingsReplicationMode(GlobalTableSettingsReplicationMode value) {
    m_globalTableSettingsReplicationModeHasBeenSet = true;
    m_globalTableSettingsReplicationMode = value;
  }
  inline TableDescription& WithGlobalTableSettingsReplicationMode(GlobalTableSettingsReplicationMode value) {
    SetGlobalTableSettingsReplicationMode(value);
    return *this;
  }
 
 
  inline const RestoreSummary& GetRestoreSummary() const { return m_restoreSummary; }
  inline bool RestoreSummaryHasBeenSet() const { return m_restoreSummaryHasBeenSet; }
  template <typename RestoreSummaryT = RestoreSummary>
  void SetRestoreSummary(RestoreSummaryT&& value) {
    m_restoreSummaryHasBeenSet = true;
    m_restoreSummary = std::forward<RestoreSummaryT>(value);
  }
  template <typename RestoreSummaryT = RestoreSummary>
  TableDescription& WithRestoreSummary(RestoreSummaryT&& value) {
    SetRestoreSummary(std::forward<RestoreSummaryT>(value));
    return *this;
  }
 
 
  inline const SSEDescription& GetSSEDescription() const { return m_sSEDescription; }
  inline bool SSEDescriptionHasBeenSet() const { return m_sSEDescriptionHasBeenSet; }
  template <typename SSEDescriptionT = SSEDescription>
  void SetSSEDescription(SSEDescriptionT&& value) {
    m_sSEDescriptionHasBeenSet = true;
    m_sSEDescription = std::forward<SSEDescriptionT>(value);
  }
  template <typename SSEDescriptionT = SSEDescription>
  TableDescription& WithSSEDescription(SSEDescriptionT&& value) {
    SetSSEDescription(std::forward<SSEDescriptionT>(value));
    return *this;
  }
 
 
  inline const ArchivalSummary& GetArchivalSummary() const { return m_archivalSummary; }
  inline bool ArchivalSummaryHasBeenSet() const { return m_archivalSummaryHasBeenSet; }
  template <typename ArchivalSummaryT = ArchivalSummary>
  void SetArchivalSummary(ArchivalSummaryT&& value) {
    m_archivalSummaryHasBeenSet = true;
    m_archivalSummary = std::forward<ArchivalSummaryT>(value);
  }
  template <typename ArchivalSummaryT = ArchivalSummary>
  TableDescription& WithArchivalSummary(ArchivalSummaryT&& value) {
    SetArchivalSummary(std::forward<ArchivalSummaryT>(value));
    return *this;
  }
 
 
  inline const TableClassSummary& GetTableClassSummary() const { return m_tableClassSummary; }
  inline bool TableClassSummaryHasBeenSet() const { return m_tableClassSummaryHasBeenSet; }
  template <typename TableClassSummaryT = TableClassSummary>
  void SetTableClassSummary(TableClassSummaryT&& value) {
    m_tableClassSummaryHasBeenSet = true;
    m_tableClassSummary = std::forward<TableClassSummaryT>(value);
  }
  template <typename TableClassSummaryT = TableClassSummary>
  TableDescription& WithTableClassSummary(TableClassSummaryT&& value) {
    SetTableClassSummary(std::forward<TableClassSummaryT>(value));
    return *this;
  }
 
 
  inline bool GetDeletionProtectionEnabled() const { return m_deletionProtectionEnabled; }
  inline bool DeletionProtectionEnabledHasBeenSet() const { return m_deletionProtectionEnabledHasBeenSet; }
  inline void SetDeletionProtectionEnabled(bool value) {
    m_deletionProtectionEnabledHasBeenSet = true;
    m_deletionProtectionEnabled = value;
  }
  inline TableDescription& WithDeletionProtectionEnabled(bool value) {
    SetDeletionProtectionEnabled(value);
    return *this;
  }
 
 
  inline const OnDemandThroughput& GetOnDemandThroughput() const { return m_onDemandThroughput; }
  inline bool OnDemandThroughputHasBeenSet() const { return m_onDemandThroughputHasBeenSet; }
  template <typename OnDemandThroughputT = OnDemandThroughput>
  void SetOnDemandThroughput(OnDemandThroughputT&& value) {
    m_onDemandThroughputHasBeenSet = true;
    m_onDemandThroughput = std::forward<OnDemandThroughputT>(value);
  }
  template <typename OnDemandThroughputT = OnDemandThroughput>
  TableDescription& WithOnDemandThroughput(OnDemandThroughputT&& value) {
    SetOnDemandThroughput(std::forward<OnDemandThroughputT>(value));
    return *this;
  }
 
 
  inline const TableWarmThroughputDescription& GetWarmThroughput() const { return m_warmThroughput; }
  inline bool WarmThroughputHasBeenSet() const { return m_warmThroughputHasBeenSet; }
  template <typename WarmThroughputT = TableWarmThroughputDescription>
  void SetWarmThroughput(WarmThroughputT&& value) {
    m_warmThroughputHasBeenSet = true;
    m_warmThroughput = std::forward<WarmThroughputT>(value);
  }
  template <typename WarmThroughputT = TableWarmThroughputDescription>
  TableDescription& WithWarmThroughput(WarmThroughputT&& value) {
    SetWarmThroughput(std::forward<WarmThroughputT>(value));
    return *this;
  }
 
 
  inline MultiRegionConsistency GetMultiRegionConsistency() const { return m_multiRegionConsistency; }
  inline bool MultiRegionConsistencyHasBeenSet() const { return m_multiRegionConsistencyHasBeenSet; }
  inline void SetMultiRegionConsistency(MultiRegionConsistency value) {
    m_multiRegionConsistencyHasBeenSet = true;
    m_multiRegionConsistency = value;
  }
  inline TableDescription& WithMultiRegionConsistency(MultiRegionConsistency value) {
    SetMultiRegionConsistency(value);
    return *this;
  }
 
 
  inline const Aws::Vector<VectorIndexDescription>& GetVectorIndexes() const { return m_vectorIndexes; }
  inline bool VectorIndexesHasBeenSet() const { return m_vectorIndexesHasBeenSet; }
  template <typename VectorIndexesT = Aws::Vector<VectorIndexDescription>>
  void SetVectorIndexes(VectorIndexesT&& value) {
    m_vectorIndexesHasBeenSet = true;
    m_vectorIndexes = std::forward<VectorIndexesT>(value);
  }
  template <typename VectorIndexesT = Aws::Vector<VectorIndexDescription>>
  TableDescription& WithVectorIndexes(VectorIndexesT&& value) {
    SetVectorIndexes(std::forward<VectorIndexesT>(value));
    return *this;
  }
  template <typename VectorIndexesT = VectorIndexDescription>
  TableDescription& AddVectorIndexes(VectorIndexesT&& value) {
    m_vectorIndexesHasBeenSet = true;
    m_vectorIndexes.emplace_back(std::forward<VectorIndexesT>(value));
    return *this;
  }
 private:
  Aws::Vector<AttributeDefinition> m_attributeDefinitions;
 
  Aws::String m_tableName;
 
  Aws::Vector<KeySchemaElement> m_keySchema;
 
  TableStatus m_tableStatus{TableStatus::NOT_SET};
 
  Aws::Utils::DateTime m_creationDateTime{};
 
  ProvisionedThroughputDescription m_provisionedThroughput;
 
  long long m_tableSizeBytes{0};
 
  long long m_itemCount{0};
 
  Aws::String m_tableArn;
 
  Aws::String m_tableId;
 
  BillingModeSummary m_billingModeSummary;
 
  Aws::Vector<LocalSecondaryIndexDescription> m_localSecondaryIndexes;
 
  Aws::Vector<GlobalSecondaryIndexDescription> m_globalSecondaryIndexes;
 
  StreamSpecification m_streamSpecification;
 
  Aws::String m_latestStreamLabel;
 
  Aws::String m_latestStreamArn;
 
  Aws::String m_globalTableVersion;
 
  Aws::Vector<ReplicaDescription> m_replicas;
 
  Aws::Vector<GlobalTableWitnessDescription> m_globalTableWitnesses;
 
  GlobalTableSettingsReplicationMode m_globalTableSettingsReplicationMode{GlobalTableSettingsReplicationMode::NOT_SET};
 
  RestoreSummary m_restoreSummary;
 
  SSEDescription m_sSEDescription;
 
  ArchivalSummary m_archivalSummary;
 
  TableClassSummary m_tableClassSummary;
 
  bool m_deletionProtectionEnabled{false};
 
  OnDemandThroughput m_onDemandThroughput;
 
  TableWarmThroughputDescription m_warmThroughput;
 
  MultiRegionConsistency m_multiRegionConsistency{MultiRegionConsistency::NOT_SET};
 
  Aws::Vector<VectorIndexDescription> m_vectorIndexes;
  bool m_attributeDefinitionsHasBeenSet = false;
  bool m_tableNameHasBeenSet = false;
  bool m_keySchemaHasBeenSet = false;
  bool m_tableStatusHasBeenSet = false;
  bool m_creationDateTimeHasBeenSet = false;
  bool m_provisionedThroughputHasBeenSet = false;
  bool m_tableSizeBytesHasBeenSet = false;
  bool m_itemCountHasBeenSet = false;
  bool m_tableArnHasBeenSet = false;
  bool m_tableIdHasBeenSet = false;
  bool m_billingModeSummaryHasBeenSet = false;
  bool m_localSecondaryIndexesHasBeenSet = false;
  bool m_globalSecondaryIndexesHasBeenSet = false;
  bool m_streamSpecificationHasBeenSet = false;
  bool m_latestStreamLabelHasBeenSet = false;
  bool m_latestStreamArnHasBeenSet = false;
  bool m_globalTableVersionHasBeenSet = false;
  bool m_replicasHasBeenSet = false;
  bool m_globalTableWitnessesHasBeenSet = false;
  bool m_globalTableSettingsReplicationModeHasBeenSet = false;
  bool m_restoreSummaryHasBeenSet = false;
  bool m_sSEDescriptionHasBeenSet = false;
  bool m_archivalSummaryHasBeenSet = false;
  bool m_tableClassSummaryHasBeenSet = false;
  bool m_deletionProtectionEnabledHasBeenSet = false;
  bool m_onDemandThroughputHasBeenSet = false;
  bool m_warmThroughputHasBeenSet = false;
  bool m_multiRegionConsistencyHasBeenSet = false;
  bool m_vectorIndexesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DynamoDB
}  // namespace Aws