Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that CloudWatch Observability Admin Service can respond with.

Structs

ActionCondition

Condition that matches based on the specific WAF action taken on the request.

AdvancedEventSelector

Advanced event selectors let you create fine-grained selectors for management, data, and network activity events.

AdvancedFieldSelector

Defines criteria for selecting resources based on field values.

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.

CloudtrailParameters

Parameters specific to Amazon Web Services CloudTrail telemetry configuration.

Condition

A single condition that can match based on WAF rule action or label name.

ConfigurationSummary

Provides a summary of pipeline configuration components including sources, processors, and destinations.

DataSource

Information about a data source associated with the telemetry pipeline. For CloudWatch Logs sources, this includes both a name and type extracted from the log event metadata. For third-party sources (such as S3), this includes only a name, with the type field left empty.

DestinationLogsConfiguration

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

ElbLoadBalancerLoggingParameters

Configuration parameters for ELB load balancer logging, including output format and field delimiter settings.

Encryption

Defines the encryption configuration for S3 Table integrations, including the encryption algorithm and KMS key settings.

FieldToMatch

Specifies a field in the request to redact from WAF logs, such as headers, query parameters, or body content.

Filter

A single filter condition that specifies behavior, requirement, and matching conditions for WAF log records.

IntegrationSummary

Contains summary information about an S3 Table integration for listing operations.

LabelNameCondition

Condition that matches based on WAF rule labels, with label names limited to 1024 characters.

LogDeliveryParameters

Configuration parameters for Amazon Bedrock AgentCore logging, including logType settings.

LoggingFilter

Configuration that determines which WAF log records to keep or drop based on specified conditions.

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.

PipelineOutput

Contains the output from pipeline test operations, including processed records and any errors encountered.

PipelineOutputError

Contains detailed error information from pipeline test operations, providing structured error responses for better debugging and troubleshooting capabilities.

Record

Represents a test record structure used for pipeline testing operations to validate data processing.

SingleHeader

Structure containing a name field limited to 64 characters for header or query parameter identification.

Source

A list of source plugin types used in the pipeline configuration (such as cloudwatch_logs or s3). Currently supports a single source per pipeline, but is structured as a list to accommodate multiple pipelines in the configuration.

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.

TelemetryPipeline

Represents a complete telemetry pipeline resource with configuration, status, and metadata for data processing and transformation.

TelemetryPipelineConfiguration

Defines the configuration for a telemetry pipeline, including how data flows from sources through processors to destinations.

TelemetryPipelineStatusReason

Provides detailed information about the status of a telemetry pipeline, including reasons for specific states.

TelemetryPipelineSummary

Contains summary information about a telemetry pipeline for listing operations.

TelemetryRule

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

TelemetryRuleSummary

A summary of a telemetry rule's key properties.

ValidationError

Represents a detailed validation error with message, reason, and field mapping for comprehensive error reporting.

VpcFlowLogParameters

Configuration parameters specific to VPC Flow Logs.

WafLoggingParameters

Configuration parameters for WAF logging, including redacted fields and logging filters.

Enums

Action

When writing a match expression against Action, 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.

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.

FilterBehavior

When writing a match expression against FilterBehavior, 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.

FilterRequirement

When writing a match expression against FilterRequirement, 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.

IntegrationStatus

When writing a match expression against IntegrationStatus, 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.

LogType

When writing a match expression against LogType, 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.

OutputFormat

When writing a match expression against OutputFormat, 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.

RecordFormat

When writing a match expression against RecordFormat, 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.

SseAlgorithm

When writing a match expression against SseAlgorithm, 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.

TelemetryEnrichmentStatus

When writing a match expression against TelemetryEnrichmentStatus, 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.

TelemetryPipelineStatus

When writing a match expression against TelemetryPipelineStatus, 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.

TelemetrySourceType

When writing a match expression against TelemetrySourceType, 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.

WafLogType

When writing a match expression against WafLogType, 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.