Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that CloudWatch Observability Admin Service can respond with.

Structs

CentralizationRule

Defines how telemetry data should be centralized across an Amazon Web Services Organization, including source and destination configurations.

CentralizationRuleDestination

Configuration specifying the primary destination for centralized telemetry data.

CentralizationRuleSource

Configuration specifying the source of telemetry data to be centralized.

CentralizationRuleSummary

A summary of a centralization rule's key properties and status.

DestinationLogsConfiguration

Configuration for centralization destination log groups, including encryption and backup settings.

LogsBackupConfiguration

Configuration for backing up centralized log data to a secondary region.

LogsEncryptionConfiguration

Configuration for encrypting centralized log groups. This configuration is only applied to destination log groups for which the corresponding source log groups are encrypted using Customer Managed KMS Keys.

SourceLogsConfiguration

Configuration for selecting and handling source log groups for centralization.

TelemetryConfiguration

A model representing the state of a resource within an account according to telemetry config.

TelemetryDestinationConfiguration

Configuration specifying where and how telemetry data should be delivered for Amazon Web Services resources.

TelemetryRule

Defines how telemetry should be configured for specific Amazon Web Services resources.

TelemetryRuleSummary

A summary of a telemetry rule's key properties.

VpcFlowLogParameters

Configuration parameters specific to VPC Flow Logs.

Enums

CentralizationFailureReason

When writing a match expression against CentralizationFailureReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DestinationType

When writing a match expression against DestinationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EncryptedLogGroupStrategy

When writing a match expression against EncryptedLogGroupStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EncryptionConflictResolutionStrategy

When writing a match expression against EncryptionConflictResolutionStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EncryptionStrategy

When writing a match expression against EncryptionStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceType

When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RuleHealth

When writing a match expression against RuleHealth, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Status

When writing a match expression against Status, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TelemetryState

When writing a match expression against TelemetryState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TelemetryType

When writing a match expression against TelemetryType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.