Module types

Source

Expand description

Data structures used by operation inputs/outputs.

Modules§

builders: Builders
error: Error types that Amazon OpenSearch Service can respond with.

Structs§

AccessPoliciesStatus

The configured access rules for the domain's search endpoint, and the current status of those rules.

AdditionalLimit

List of limits that are specific to a given instance type.

AdvancedOptionsStatus

Status of the advanced options for the specified domain. The following options are available:

"rest.action.multi.allow_explicit_index": "true" | "false" - Note the use of a string rather than a boolean. Specifies whether explicit references to indexes are allowed inside the body of HTTP requests. If you want to configure access policies for domain sub-resources, such as specific indexes and domain APIs, you must disable this property. Default is true.
"indices.fielddata.cache.size": "80" - Note the use of a string rather than a boolean. Specifies the percentage of heap space allocated to field data. Default is unbounded.
"indices.query.bool.max_clause_count": "1024" - Note the use of a string rather than a boolean. Specifies the maximum number of clauses allowed in a Lucene boolean query. Default is 1,024. Queries with more than the permitted number of clauses result in a TooManyClauses error.
"override_main_response_version": "true" | "false" - Note the use of a string rather than a boolean. Specifies whether the domain reports its version as 7.10 to allow Elasticsearch OSS clients and plugins to continue working with it. Default is false when creating a domain and true when upgrading a domain.

For more information, see Advanced cluster parameters.

AdvancedSecurityOptions

Container for fine-grained access control settings.

AdvancedSecurityOptionsInput

Options for enabling and configuring fine-grained access control. For more information, see Fine-grained access control in Amazon OpenSearch Service.

AdvancedSecurityOptionsStatus

The status of fine-grained access control settings for a domain.

AimlOptionsInput

Container for parameters required to enable all machine learning features.

AimlOptionsOutput

Container for parameters representing the state of machine learning features on the specified domain.

AimlOptionsStatus

The status of machine learning options on the specified domain.

AppConfig

Configuration settings for an OpenSearch application. For more information, see see Using the OpenSearch user interface in Amazon OpenSearch Service.

ApplicationSummary

Basic details of an OpenSearch application.

AuthorizedPrincipal

Information about an Amazon Web Services account or service that has access to an Amazon OpenSearch Service domain through the use of an interface VPC endpoint.

AutoTune

Information about an Auto-Tune action. For more information, see Auto-Tune for Amazon OpenSearch Service.

AutoTuneDetails

Specifies details about a scheduled Auto-Tune action. For more information, see Auto-Tune for Amazon OpenSearch Service.

AutoTuneMaintenanceSchedule

This object is deprecated. Use the domain's off-peak window to schedule Auto-Tune optimizations. For migration instructions, see Migrating from Auto-Tune maintenance windows.

The Auto-Tune maintenance schedule. For more information, see Auto-Tune for Amazon OpenSearch Service.

AutoTuneOptions

Auto-Tune settings when updating a domain. For more information, see Auto-Tune for Amazon OpenSearch Service.

AutoTuneOptionsInput

Options for configuring Auto-Tune. For more information, see Auto-Tune for Amazon OpenSearch Service

AutoTuneOptionsOutput

The Auto-Tune settings for a domain, displayed when enabling or disabling Auto-Tune.

AutoTuneOptionsStatus

The Auto-Tune status for the domain.

AutoTuneStatus

The current status of Auto-Tune for the domain. For more information, see Auto-Tune for Amazon OpenSearch Service.

AvailabilityZoneInfo

Information about an Availability Zone on a domain.

AwsDomainInformation

Information about an Amazon OpenSearch Service domain.

CancelledChangeProperty

A property change that was cancelled for an Amazon OpenSearch Service domain.

ChangeProgressDetails

Container for information about a configuration change happening on a domain.

ChangeProgressStage

Progress details for each stage of a domain update.

ChangeProgressStatusDetails

The progress details of a specific domain configuration change.

CloudWatchDirectQueryDataSource

Configuration details for a CloudWatch Logs data source that can be used for direct queries.

ClusterConfig

Container for the cluster configuration of an OpenSearch Service domain. For more information, see Creating and managing Amazon OpenSearch Service domains.

ClusterConfigStatus

The cluster configuration status for a domain.

CognitoOptions

Container for the parameters required to enable Cognito authentication for an OpenSearch Service domain. For more information, see Configuring Amazon Cognito authentication for OpenSearch Dashboards.

CognitoOptionsStatus

The status of the Cognito options for the specified domain.

ColdStorageOptions

Container for the parameters required to enable cold storage for an OpenSearch Service domain. For more information, see Cold storage for Amazon OpenSearch Service.

CompatibleVersionsMap

A map of OpenSearch or Elasticsearch versions and the versions you can upgrade them to.

ConnectionProperties

The connection properties of an outbound connection.

CrossClusterSearchConnectionProperties

Cross-cluster search specific connection properties.

DataSource

Data sources that are associated with an OpenSearch Application.

DataSourceDetails

Details about a direct-query data source.

DescribePackagesFilter

A filter to apply to the DescribePackage response.

DirectQueryDataSource

The configuration details for a data source that can be directly queried.

DomainConfig

Container for the configuration of an OpenSearch Service domain.

DomainEndpointOptions

Options to configure a custom endpoint for an OpenSearch Service domain.

DomainEndpointOptionsStatus

The configured endpoint options for a domain and their current status.

DomainInfo

Information about an OpenSearch Service domain.

DomainInformationContainer

Container for information about an OpenSearch Service domain.

DomainMaintenanceDetails

Container for the domain maintenance details.

DomainNodesStatus

Container for information about nodes on the domain.

DomainPackageDetails

Information about a package that is associated with a domain. For more information, see Custom packages for Amazon OpenSearch Service.

DomainStatus

The current status of an OpenSearch Service domain.

DryRunProgressStatus

Information about the progress of a pre-upgrade dry run analysis.

DryRunResults

Results of a dry run performed in an update domain request.

Duration

The duration of a maintenance schedule. For more information, see Auto-Tune for Amazon OpenSearch Service.

EbsOptions

Container for the parameters required to enable EBS-based storage for an OpenSearch Service domain.

EbsOptionsStatus

The status of the EBS options for the specified OpenSearch Service domain.

EncryptionAtRestOptions

Specifies whether the domain should encrypt data at rest, and if so, the Key Management Service (KMS) key to use. Can only be used when creating a new domain or enabling encryption at rest for the first time on an existing domain. You can't modify this parameter after it's already been specified.

EncryptionAtRestOptionsStatus

Status of the encryption at rest options for the specified OpenSearch Service domain.

EnvironmentInfo

Information about the active domain environment.

ErrorDetails

Additional information if the package is in an error state. Null otherwise.

Filter

A filter used to limit results when describing inbound or outbound cross-cluster connections. You can specify multiple values per filter. A cross-cluster connection must match at least one of the specified values for it to be returned from an operation.

IamIdentityCenterOptions

Configuration settings for IAM Identity Center in an OpenSearch Application.

IamIdentityCenterOptionsInput

Configuration settings for enabling and managing IAM Identity Center.

IdentityCenterOptions

Settings container for integrating IAM Identity Center with OpenSearch UI applications, which enables enabling secure user authentication and access control across multiple data sources. This setup supports single sign-on (SSO) through IAM Identity Center, allowing centralized user management.

IdentityCenterOptionsInput

Configuration settings for enabling and managing IAM Identity Center.

IdentityCenterOptionsStatus

The status of IAM Identity Center configuration settings for a domain.

InboundConnection

Describes an inbound cross-cluster connection for Amazon OpenSearch Service. For more information, see Cross-cluster search for Amazon OpenSearch Service.

InboundConnectionStatus

The status of an inbound cross-cluster connection for OpenSearch Service.

InstanceCountLimits

Limits on the number of instances that can be created in OpenSearch Service for a given instance type.

InstanceLimits

Instance-related attributes that are available for a given instance type.

InstanceTypeDetails

Lists all instance types and available features for a given OpenSearch or Elasticsearch version.

IpAddressTypeStatus

The IP address type status for the domain.

JwtOptionsInput

The JWT authentication and authorization configuration for an Amazon OpenSearch Service domain.

JwtOptionsOutput

Describes the JWT options configured for the domain.

KeyStoreAccessOption

The configuration parameters to enable access to the key store required by the package.

Limits

Limits for a given instance type and for each of its roles.

LogPublishingOption

Specifies whether the Amazon OpenSearch Service domain publishes the OpenSearch application and slow logs to Amazon CloudWatch. For more information, see Monitoring OpenSearch logs with Amazon CloudWatch Logs.

After you enable log publishing, you still have to enable the collection of slow logs using the OpenSearch REST API.

LogPublishingOptionsStatus

The configured log publishing options for the domain and their current status.

MasterUserOptions

Credentials for the master user for a domain.

ModifyingProperties

Information about the domain properties that are currently being modified.

NaturalLanguageQueryGenerationOptionsInput

Container for parameters required to enable the natural language query generation feature.

NaturalLanguageQueryGenerationOptionsOutput

Container for parameters representing the state of the natural language query generation feature on the specified domain.

NodeConfig

Configuration options for defining the setup of any node type within the cluster.

NodeOption

Configuration settings for defining the node type within a cluster.

NodeToNodeEncryptionOptions

Enables or disables node-to-node encryption. For more information, see Node-to-node encryption for Amazon OpenSearch Service.

NodeToNodeEncryptionOptionsStatus

Status of the node-to-node encryption options for the specified domain.

OffPeakWindow

A custom 10-hour, low-traffic window during which OpenSearch Service can perform mandatory configuration changes on the domain. These actions can include scheduled service software updates and blue/green Auto-Tune enhancements. OpenSearch Service will schedule these actions during the window that you specify.

If you don't specify a window start time, it defaults to 10:00 P.M. local time.

For more information, see Defining off-peak maintenance windows for Amazon OpenSearch Service.

OffPeakWindowOptions

Options for a domain's off-peak window, during which OpenSearch Service can perform mandatory configuration changes on the domain.

OffPeakWindowOptionsStatus

The status of off-peak window options for a domain.

OptionStatus

Provides the current status of an entity.

OutboundConnection

Specifies details about an outbound cross-cluster connection.

OutboundConnectionStatus

The status of an outbound cross-cluster connection.

PackageAssociationConfiguration

The configuration for associating a package with a domain.

PackageConfiguration

The configuration parameters for a package.

PackageDetails

Basic information about a package.

PackageDetailsForAssociation

Details of a package that is associated with a domain.

PackageEncryptionOptions

Encryption options for a package.

PackageSource

The Amazon S3 location to import the package from.

PackageVendingOptions

Configuration options for determining whether a package can be made available for use by other users.

PackageVersionHistory

Details about a package version.

PluginProperties

Basic information about the plugin.

RecurringCharge

Contains the specific price and frequency of a recurring charges for an OpenSearch Reserved Instance, or for a Reserved Instance offering.

ReservedInstance

Details of an OpenSearch Reserved Instance.

ReservedInstanceOffering

Details of an OpenSearch Reserved Instance offering.

S3GlueDataCatalog

Information about the Amazon S3 Glue Data Catalog.

SamlIdp

The SAML identity povider information.

SamlOptionsInput

The SAML authentication configuration for an Amazon OpenSearch Service domain.

SamlOptionsOutput

Describes the SAML application configured for the domain.

ScheduledAction

Information about a scheduled configuration change for an OpenSearch Service domain. This actions can be a service software update or a blue/green Auto-Tune enhancement.

ScheduledAutoTuneDetails

Specifies details about a scheduled Auto-Tune action. For more information, see Auto-Tune for Amazon OpenSearch Service.

SecurityLakeDirectQueryDataSource

Configuration details for a Security Lake data source that can be used for direct queries.

ServiceSoftwareOptions

The current status of the service software for an Amazon OpenSearch Service domain. For more information, see Service software updates in Amazon OpenSearch Service.

SnapshotOptions

The time, in UTC format, when OpenSearch Service takes a daily automated snapshot of the specified domain. Default is 0 hours.

SnapshotOptionsStatus

Container for information about a daily automated snapshot for an OpenSearch Service domain.

SoftwareUpdateOptions

Options for configuring service software updates for a domain.

SoftwareUpdateOptionsStatus

The status of the service software options for a domain.

StorageType

A list of storage types for an Amazon OpenSearch Service domain that are available for a given intance type.

StorageTypeLimit

Limits that are applicable for the given Amazon OpenSearch Service storage type.

Tag

A tag (key-value pair) for an Amazon OpenSearch Service resource.

UpgradeHistory

History of the last 10 upgrades and upgrade eligibility checks for an Amazon OpenSearch Service domain.

UpgradeStepItem

Represents a single step of an upgrade or upgrade eligibility check workflow.

ValidationFailure

A validation failure that occurred as the result of a pre-update validation check (verbose dry run) on a domain.

VersionStatus

The status of the the OpenSearch or Elasticsearch version options for the specified Amazon OpenSearch Service domain.

VpcDerivedInfo

Information about the subnets and security groups for an Amazon OpenSearch Service domain provisioned within a virtual private cloud (VPC). For more information, see Launching your Amazon OpenSearch Service domains using a VPC. This information only exists if the domain was created with VPCOptions.

VpcDerivedInfoStatus

Status of the VPC options for a specified domain.

VpcEndpoint

The connection endpoint for connecting to an Amazon OpenSearch Service domain through a proxy.

VpcEndpointError

Error information when attempting to describe an Amazon OpenSearch Service-managed VPC endpoint.

VpcEndpointSummary

Summary information for an Amazon OpenSearch Service-managed VPC endpoint.

VpcOptions

Options to specify the subnets and security groups for an Amazon OpenSearch Service VPC endpoint. For more information, see Launching your Amazon OpenSearch Service domains using a VPC.

WindowStartTime

The desired start time for an off-peak maintenance window.

ZoneAwarenessConfig

The zone awareness configuration for an Amazon OpenSearch Service domain.

Enums§

ActionSeverity: When writing a match expression against ActionSeverity, 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.
ActionStatus: When writing a match expression against ActionStatus, 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.
ActionType: When writing a match expression against ActionType, 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.
AppConfigType: When writing a match expression against AppConfigType, 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.
ApplicationStatus: When writing a match expression against ApplicationStatus, 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.
AutoTuneDesiredState: When writing a match expression against AutoTuneDesiredState, 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.
AutoTuneState: When writing a match expression against AutoTuneState, 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.
AutoTuneType: When writing a match expression against AutoTuneType, 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.
AwsServicePrincipal: When writing a match expression against AwsServicePrincipal, 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.
ConfigChangeStatus: When writing a match expression against ConfigChangeStatus, 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.
ConnectionMode: When writing a match expression against ConnectionMode, 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.
DataSourceStatus: When writing a match expression against DataSourceStatus, 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.
DataSourceType: The type of data source.
DeploymentStatus: When writing a match expression against DeploymentStatus, 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.
DescribePackagesFilterName: When writing a match expression against DescribePackagesFilterName, 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.
DirectQueryDataSourceType: The type of data source that is used for direct queries. This is a supported Amazon Web Services service, such as CloudWatch Logs or Security Lake.
DomainHealth: When writing a match expression against DomainHealth, 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.
DomainPackageStatus: When writing a match expression against DomainPackageStatus, 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.
DomainProcessingStatusType: When writing a match expression against DomainProcessingStatusType, 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.
DomainState: When writing a match expression against DomainState, 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.
DryRunMode: When writing a match expression against DryRunMode, 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.
EngineType: When writing a match expression against EngineType, 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.
InboundConnectionStatusCode: When writing a match expression against InboundConnectionStatusCode, 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.
InitiatedBy: When writing a match expression against InitiatedBy, 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.
IpAddressType: When writing a match expression against IpAddressType, 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.
MaintenanceStatus: When writing a match expression against MaintenanceStatus, 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.
MaintenanceType: When writing a match expression against MaintenanceType, 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.
MasterNodeStatus: When writing a match expression against MasterNodeStatus, 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.
NaturalLanguageQueryGenerationCurrentState: When writing a match expression against NaturalLanguageQueryGenerationCurrentState, 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.
NaturalLanguageQueryGenerationDesiredState: When writing a match expression against NaturalLanguageQueryGenerationDesiredState, 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.
NodeOptionsNodeType: When writing a match expression against NodeOptionsNodeType, 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.
NodeStatus: When writing a match expression against NodeStatus, 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.
NodeType: When writing a match expression against NodeType, 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.
OpenSearchPartitionInstanceType: When writing a match expression against OpenSearchPartitionInstanceType, 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.
OpenSearchWarmPartitionInstanceType: When writing a match expression against OpenSearchWarmPartitionInstanceType, 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.
OptionState: When writing a match expression against OptionState, 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.
OutboundConnectionStatusCode: When writing a match expression against OutboundConnectionStatusCode, 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.
OverallChangeStatus: When writing a match expression against OverallChangeStatus, 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.
PackageScopeOperationEnum: When writing a match expression against PackageScopeOperationEnum, 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.
PackageStatus: When writing a match expression against PackageStatus, 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.
PackageType: When writing a match expression against PackageType, 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.
PrincipalType: When writing a match expression against PrincipalType, 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.
PropertyValueType: When writing a match expression against PropertyValueType, 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.
RequirementLevel: When writing a match expression against RequirementLevel, 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.
ReservedInstancePaymentOption: When writing a match expression against ReservedInstancePaymentOption, 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.
RolesKeyIdCOption: When writing a match expression against RolesKeyIdCOption, 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.
RollbackOnDisable: When writing a match expression against RollbackOnDisable, 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.
ScheduleAt: When writing a match expression against ScheduleAt, 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.
ScheduledAutoTuneActionType: When writing a match expression against ScheduledAutoTuneActionType, 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.
ScheduledAutoTuneSeverityType: When writing a match expression against ScheduledAutoTuneSeverityType, 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.
ScheduledBy: When writing a match expression against ScheduledBy, 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.
SkipUnavailableStatus: When writing a match expression against SkipUnavailableStatus, 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.
SubjectKeyIdCOption: When writing a match expression against SubjectKeyIdCOption, 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.
TimeUnit: When writing a match expression against TimeUnit, 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.
TlsSecurityPolicy: When writing a match expression against TlsSecurityPolicy, 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.
UpgradeStatus: When writing a match expression against UpgradeStatus, 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.
UpgradeStep: When writing a match expression against UpgradeStep, 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.
VolumeType: When writing a match expression against VolumeType, 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.
VpcEndpointErrorCode: When writing a match expression against VpcEndpointErrorCode, 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.
VpcEndpointStatus: When writing a match expression against VpcEndpointStatus, 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.
ZoneStatus: When writing a match expression against ZoneStatus, 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.

Module typesCopy item path

Modules§

Structs§

Enums§

Module types