Module aws_sdk_glue::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that AWS Glue can respond with.

Structs

• Action

  Defines an action to be initiated by a trigger.

• Aggregate

  Specifies a transform that groups rows by chosen fields and computes the aggregated value by specified function.

• AggregateOperation

  Specifies the set of parameters needed to perform aggregation in the aggregate transform.

• AmazonRedshiftAdvancedOption

  Specifies an optional value when connecting to the Redshift cluster.

• AmazonRedshiftNodeData

  Specifies an Amazon Redshift node.

• AmazonRedshiftSource

  Specifies an Amazon Redshift source.

• AmazonRedshiftTarget

  Specifies an Amazon Redshift target.

• ApplyMapping

  Specifies a transform that maps data property keys in the data source to data property keys in the data target. You can rename keys, modify the data types for keys, and choose which keys to drop from the dataset.

• AthenaConnectorSource

  Specifies a connector to an Amazon Athena data source.

• AuditContext

  A structure containing the Lake Formation audit context.

• BackfillError

  A list of errors that can occur when registering partition indexes for an existing table.

• BasicCatalogTarget

  Specifies a target that uses a Glue Data Catalog table.

• BatchStopJobRunError

  Records an error that occurred when attempting to stop a specified job run.

• BatchStopJobRunSuccessfulSubmission

  Records a successful request to stop a specified JobRun.

• BatchUpdatePartitionFailureEntry

  Contains information about a batch update partition error.

• BatchUpdatePartitionRequestEntry

  A structure that contains the values and structure used to update a partition.

• BinaryColumnStatisticsData

  Defines column statistics supported for bit sequence data values.

• Blueprint

  The details of a blueprint.

• BlueprintDetails

  The details of a blueprint.

• BlueprintRun

  The details of a blueprint run.

• BooleanColumnStatisticsData

  Defines column statistics supported for Boolean data columns.

• CatalogDeltaSource

  Specifies a Delta Lake data source that is registered in the Glue Data Catalog.

• CatalogEntry

  Specifies a table definition in the Glue Data Catalog.

• CatalogHudiSource

  Specifies a Hudi data source that is registered in the Glue Data Catalog.

• CatalogImportStatus

  A structure containing migration status information.

• CatalogKafkaSource

  Specifies an Apache Kafka data store in the Data Catalog.

• CatalogKinesisSource

  Specifies a Kinesis data source in the Glue Data Catalog.

• CatalogSchemaChangePolicy

  A policy that specifies update behavior for the crawler.

• CatalogSource

  Specifies a data store in the Glue Data Catalog.

• CatalogTarget

  Specifies an Glue Data Catalog target.

• Classifier

  Classifiers are triggered during a crawl task. A classifier checks whether a given file is in a format it can handle. If it is, the classifier creates a schema in the form of a StructType object that matches that data format.

• CloudWatchEncryption

  Specifies how Amazon CloudWatch data should be encrypted.

• CodeGenConfigurationNode

  CodeGenConfigurationNode enumerates all valid Node types. One and only one of its member variables can be populated.

• CodeGenEdge

  Represents a directional edge in a directed acyclic graph (DAG).

• CodeGenNode

  Represents a node in a directed acyclic graph (DAG)

• CodeGenNodeArg

  An argument or property of a node.

• Column

  A column in a Table.

• ColumnError

  Encapsulates a column name that failed and the reason for failure.

• ColumnImportance

  A structure containing the column name and column importance score for a column.

• ColumnRowFilter

  A filter that uses both column-level and row-level filtering.

• ColumnStatistics

  Represents the generated column-level statistics for a table or partition.

• ColumnStatisticsData

  Contains the individual types of column statistics data. Only one data object should be set and indicated by the Type attribute.

• ColumnStatisticsError

  Encapsulates a ColumnStatistics object that failed and the reason for failure.

• Condition

  Defines a condition under which a trigger fires.

• ConfusionMatrix

  The confusion matrix shows you what your transform is predicting accurately and what types of errors it is making.

• Connection

  Defines a connection to a data source.

• ConnectionInput

  A structure that is used to specify a connection to create or update.

• ConnectionPasswordEncryption

  The data structure used by the Data Catalog to encrypt the password as part of CreateConnection or UpdateConnection and store it in the ENCRYPTED_PASSWORD field in the connection properties. You can enable catalog encryption or only password encryption.

• ConnectionsList

  Specifies the connections used by a job.

• Crawl

  The details of a crawl in the workflow.

• Crawler

  Specifies a crawler program that examines a data source and uses classifiers to try to determine its schema. If successful, the crawler records metadata concerning the data source in the Glue Data Catalog.

• CrawlerHistory

  Contains the information for a run of a crawler.

• CrawlerMetrics

  Metrics for a specified crawler.

• CrawlerNodeDetails

  The details of a Crawler node present in the workflow.

• CrawlerTargets

  Specifies data stores to crawl.

• CrawlsFilter

  A list of fields, comparators and value that you can use to filter the crawler runs for a specified crawler.

• CreateCsvClassifierRequest

  Specifies a custom CSV classifier for CreateClassifier to create.

• CreateGrokClassifierRequest

  Specifies a grok classifier for CreateClassifier to create.

• CreateJsonClassifierRequest

  Specifies a JSON classifier for CreateClassifier to create.

• CreateXmlClassifierRequest

  Specifies an XML classifier for CreateClassifier to create.

• CsvClassifier

  A classifier for custom CSV content.

• CustomCode

  Specifies a transform that uses custom code you provide to perform the data transformation. The output is a collection of DynamicFrames.

• CustomEntityType

  An object representing a custom pattern for detecting sensitive data across the columns and rows of your structured data.

• DataCatalogEncryptionSettings

  Contains configuration information for maintaining Data Catalog security.

• DataLakePrincipal

  The Lake Formation principal.

• DataQualityEvaluationRunAdditionalRunOptions

  Additional run options you can specify for an evaluation run.

• DataQualityResult

  Describes a data quality result.

• DataQualityResultDescription

  Describes a data quality result.

• DataQualityResultFilterCriteria

  Criteria used to return data quality results.

• DataQualityRuleRecommendationRunDescription

  Describes the result of a data quality rule recommendation run.

• DataQualityRuleRecommendationRunFilter

  A filter for listing data quality recommendation runs.

• DataQualityRuleResult

  Describes the result of the evaluation of a data quality rule.

• DataQualityRulesetEvaluationRunDescription

  Describes the result of a data quality ruleset evaluation run.

• DataQualityRulesetEvaluationRunFilter

  The filter criteria.

• DataQualityRulesetFilterCriteria

  The criteria used to filter data quality rulesets.

• DataQualityRulesetListDetails

  Describes a data quality ruleset returned by GetDataQualityRuleset.

• DataQualityTargetTable

  An object representing an Glue table.

• DataSource

  A data source (an Glue table) for which you want data quality results.

• Database

  The Database object represents a logical grouping of tables that might reside in a Hive metastore or an RDBMS.

• DatabaseIdentifier

  A structure that describes a target database for resource linking.

• DatabaseInput

  The structure used to create or update a database.

• Datatype

  A structure representing the datatype of the value.

• DateColumnStatisticsData

  Defines column statistics supported for timestamp data columns.

• DecimalColumnStatisticsData

  Defines column statistics supported for fixed-point number data columns.

• DecimalNumber

  Contains a numeric value in decimal format.

• DeltaTarget

  Specifies a Delta data store to crawl one or more Delta tables.

• DevEndpoint

  A development endpoint where a developer can remotely debug extract, transform, and load (ETL) scripts.

• DevEndpointCustomLibraries

  Custom libraries to be loaded into a development endpoint.

• DirectJdbcSource

  Specifies the direct JDBC source connection.

• DirectKafkaSource

  Specifies an Apache Kafka data store.

• DirectKinesisSource

  Specifies a direct Amazon Kinesis data source.

• DirectSchemaChangePolicy

  A policy that specifies update behavior for the crawler.

• DoubleColumnStatisticsData

  Defines column statistics supported for floating-point number data columns.

• DqResultsPublishingOptions

  Options to configure how your data quality evaluation results are published.

• DqStopJobOnFailureOptions

  Options to configure how your job will stop if your data quality evaluation fails.

• DropDuplicates

  Specifies a transform that removes rows of repeating data from a data set.

• DropFields

  Specifies a transform that chooses the data property keys that you want to drop.

• DropNullFields

  Specifies a transform that removes columns from the dataset if all values in the column are 'null'. By default, Glue Studio will recognize null objects, but some values such as empty strings, strings that are "null", -1 integers or other placeholders such as zeros, are not automatically recognized as nulls.

• DynamicTransform

  Specifies the set of parameters needed to perform the dynamic transform.

• DynamoDbCatalogSource

  Specifies a DynamoDB data source in the Glue Data Catalog.

• DynamoDbTarget

  Specifies an Amazon DynamoDB table to crawl.

• Edge

  An edge represents a directed connection between two Glue components that are part of the workflow the edge belongs to.

• EncryptionAtRest

  Specifies the encryption-at-rest configuration for the Data Catalog.

• EncryptionConfiguration

  Specifies an encryption configuration.

• ErrorDetail

  Contains details about an error.

• ErrorDetails

  An object containing error details.

• EvaluateDataQuality

  Specifies your data quality evaluation criteria.

• EvaluateDataQualityMultiFrame

  Specifies your data quality evaluation criteria.

• EvaluationMetrics

  Evaluation metrics provide an estimate of the quality of your machine learning transform.

• EventBatchingCondition

  Batch condition that must be met (specified number of events received or batch time window expired) before EventBridge event trigger fires.

• ExecutionProperty

  An execution property of a job.

• ExportLabelsTaskRunProperties

  Specifies configuration properties for an exporting labels task run.

• FederatedDatabase

  A database that points to an entity outside the Glue Data Catalog.

• FederatedTable

  A table that points to an entity outside the Glue Data Catalog.

• FillMissingValues

  Specifies a transform that locates records in the dataset that have missing values and adds a new field with a value determined by imputation. The input data set is used to train the machine learning model that determines what the missing value should be.

• Filter

  Specifies a transform that splits a dataset into two, based on a filter condition.

• FilterExpression

  Specifies a filter expression.

• FilterValue

  Represents a single entry in the list of values for a FilterExpression.

• FindMatchesMetrics

  The evaluation metrics for the find matches algorithm. The quality of your machine learning transform is measured by getting your transform to predict some matches and comparing the results to known matches from the same dataset. The quality metrics are based on a subset of your data, so they are not precise.

• FindMatchesParameters

  The parameters to configure the find matches transform.

• FindMatchesTaskRunProperties

  Specifies configuration properties for a Find Matches task run.

• GetConnectionsFilter

  Filters the connection definitions that are returned by the GetConnections API operation.

• GluePolicy

  A structure for returning a resource policy.

• GlueSchema

  Specifies a user-defined schema when a schema cannot be determined by Glue.

• GlueStudioSchemaColumn

  Specifies a single column in a Glue schema definition.

• GlueTable

  The database and table in the Glue Data Catalog that is used for input or output data.

• GovernedCatalogSource

  Specifies the data store in the governed Glue Data Catalog.

• GovernedCatalogTarget

  Specifies a data target that writes to Amazon S3 using the Glue Data Catalog.

• GrokClassifier

  A classifier that uses grok patterns.

• HudiTarget

  Specifies an Apache Hudi data source.

• IcebergInput

  A structure that defines an Apache Iceberg metadata table to create in the catalog.

• IcebergTarget

  Specifies an Apache Iceberg data source where Iceberg tables are stored in Amazon S3.

• ImportLabelsTaskRunProperties

  Specifies configuration properties for an importing labels task run.

• JdbcConnectorOptions

  Additional connection options for the connector.

• JdbcConnectorSource

  Specifies a connector to a JDBC data source.

• JdbcConnectorTarget

  Specifies a data target that writes to Amazon S3 in Apache Parquet columnar storage.

• JdbcTarget

  Specifies a JDBC data store to crawl.

• Job

  Specifies a job definition.

• JobBookmarkEntry

  Defines a point that a job can resume processing.

• JobBookmarksEncryption

  Specifies how job bookmark data should be encrypted.

• JobCommand

  Specifies code that runs when a job is run.

• JobNodeDetails

  The details of a Job node present in the workflow.

• JobRun

  Contains information about a job run.

• JobUpdate

  Specifies information used to update an existing job definition. The previous job definition is completely overwritten by this information.

• Join

  Specifies a transform that joins two datasets into one dataset using a comparison phrase on the specified data property keys. You can use inner, outer, left, right, left semi, and left anti joins.

• JoinColumn

  Specifies a column to be joined.

• JsonClassifier

  A classifier for JSON content.

• KafkaStreamingSourceOptions

  Additional options for streaming.

• KeySchemaElement

  A partition key pair consisting of a name and a type.

• KinesisStreamingSourceOptions

  Additional options for the Amazon Kinesis streaming data source.

• LabelingSetGenerationTaskRunProperties

  Specifies configuration properties for a labeling set generation task run.

• LakeFormationConfiguration

  Specifies Lake Formation configuration settings for the crawler.

• LastActiveDefinition

  When there are multiple versions of a blueprint and the latest version has some errors, this attribute indicates the last successful blueprint definition that is available with the service.

• LastCrawlInfo

  Status and error information about the most recent crawl.

• LineageConfiguration

  Specifies data lineage configuration settings for the crawler.

• Location

  The location of resources.

• LongColumnStatisticsData

  Defines column statistics supported for integer data columns.

• Mapping

  Specifies the mapping of data property keys.

• MappingEntry

  Defines a mapping.

• Merge

  Specifies a transform that merges a DynamicFrame with a staging DynamicFrame based on the specified primary keys to identify records. Duplicate records (records with the same primary keys) are not de-duplicated.

• MetadataInfo

  A structure containing metadata information for a schema version.

• MetadataKeyValuePair

  A structure containing a key value pair for metadata.

• MicrosoftSqlServerCatalogSource

  Specifies a Microsoft SQL server data source in the Glue Data Catalog.

• MicrosoftSqlServerCatalogTarget

  Specifies a target that uses Microsoft SQL.

• MlTransform

  A structure for a machine learning transform.

• MlUserDataEncryption

  The encryption-at-rest settings of the transform that apply to accessing user data.

• MongoDbTarget

  Specifies an Amazon DocumentDB or MongoDB data store to crawl.

• MySqlCatalogSource

  Specifies a MySQL data source in the Glue Data Catalog.

• MySqlCatalogTarget

  Specifies a target that uses MySQL.

• Node

  A node represents an Glue component (trigger, crawler, or job) on a workflow graph.

• NotificationProperty

  Specifies configuration properties of a notification.

• NullCheckBoxList

  Represents whether certain values are recognized as null values for removal.

• NullValueField

  Represents a custom null value such as a zeros or other value being used as a null placeholder unique to the dataset.

• OpenTableFormatInput

  A structure representing an open format table.

• Option

  Specifies an option value.

• OracleSqlCatalogSource

  Specifies an Oracle data source in the Glue Data Catalog.

• OracleSqlCatalogTarget

  Specifies a target that uses Oracle SQL.

• Order

  Specifies the sort order of a sorted column.

• OtherMetadataValueListItem

  A structure containing other metadata for a schema version belonging to the same metadata key.

• Partition

  Represents a slice of table data.

• PartitionError

  Contains information about a partition error.

• PartitionIndex

  A structure for a partition index.

• PartitionIndexDescriptor

  A descriptor for a partition index in a table.

• PartitionInput

  The structure used to create and update a partition.

• PartitionValueList

  Contains a list of values defining partitions.

• PhysicalConnectionRequirements

  Specifies the physical requirements for a connection.

• PiiDetection

  Specifies a transform that identifies, removes or masks PII data.

• PostgreSqlCatalogSource

  Specifies a PostgresSQL data source in the Glue Data Catalog.

• PostgreSqlCatalogTarget

  Specifies a target that uses Postgres SQL.

• Predecessor

  A job run that was used in the predicate of a conditional trigger that triggered this job run.

• Predicate

  Defines the predicate of the trigger, which determines when it fires.

• PrincipalPermissions

  Permissions granted to a principal.

• PropertyPredicate

  Defines a property predicate.

• Recipe

  A Glue Studio node that uses a Glue DataBrew recipe in Glue jobs.

• RecipeReference

  A reference to a Glue DataBrew recipe.

• RecrawlPolicy

  When crawling an Amazon S3 data source after the first crawl is complete, specifies whether to crawl the entire dataset again or to crawl only folders that were added since the last crawler run. For more information, see Incremental Crawls in Glue in the developer guide.

• RedshiftSource

  Specifies an Amazon Redshift data store.

• RedshiftTarget

  Specifies a target that uses Amazon Redshift.

• RegistryId

  A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).

• RegistryListItem

  A structure containing the details for a registry.

• RelationalCatalogSource

  Specifies a Relational database data source in the Glue Data Catalog.

• RenameField

  Specifies a transform that renames a single data property key.

• ResourceUri

  The URIs for function resources.

• S3CatalogDeltaSource

  Specifies a Delta Lake data source that is registered in the Glue Data Catalog. The data source must be stored in Amazon S3.

• S3CatalogHudiSource

  Specifies a Hudi data source that is registered in the Glue Data Catalog. The Hudi data source must be stored in Amazon S3.

• S3CatalogSource

  Specifies an Amazon S3 data store in the Glue Data Catalog.

• S3CatalogTarget

  Specifies a data target that writes to Amazon S3 using the Glue Data Catalog.

• S3CsvSource

  Specifies a command-separated value (CSV) data store stored in Amazon S3.

• S3DeltaCatalogTarget

  Specifies a target that writes to a Delta Lake data source in the Glue Data Catalog.

• S3DeltaDirectTarget

  Specifies a target that writes to a Delta Lake data source in Amazon S3.

• S3DeltaSource

  Specifies a Delta Lake data source stored in Amazon S3.

• S3DirectSourceAdditionalOptions

  Specifies additional connection options for the Amazon S3 data store.

• S3DirectTarget

  Specifies a data target that writes to Amazon S3.

• S3Encryption

  Specifies how Amazon Simple Storage Service (Amazon S3) data should be encrypted.

• S3GlueParquetTarget

  Specifies a data target that writes to Amazon S3 in Apache Parquet columnar storage.

• S3HudiCatalogTarget

  Specifies a target that writes to a Hudi data source in the Glue Data Catalog.

• S3HudiDirectTarget

  Specifies a target that writes to a Hudi data source in Amazon S3.

• S3HudiSource

  Specifies a Hudi data source stored in Amazon S3.

• S3JsonSource

  Specifies a JSON data store stored in Amazon S3.

• S3ParquetSource

  Specifies an Apache Parquet data store stored in Amazon S3.

• S3SourceAdditionalOptions

  Specifies additional connection options for the Amazon S3 data store.

• S3Target

  Specifies a data store in Amazon Simple Storage Service (Amazon S3).

• Schedule

  A scheduling object using a cron statement to schedule an event.

• SchemaChangePolicy

  A policy that specifies update and deletion behaviors for the crawler.

• SchemaColumn

  A key-value pair representing a column and data type that this transform can run against. The Schema parameter of the MLTransform may contain up to 100 of these structures.

• SchemaId

  The unique ID of the schema in the Glue schema registry.

• SchemaListItem

  An object that contains minimal details for a schema.

• SchemaReference

  An object that references a schema stored in the Glue Schema Registry.

• SchemaVersionErrorItem

  An object that contains the error details for an operation on a schema version.

• SchemaVersionListItem

  An object containing the details about a schema version.

• SchemaVersionNumber

  A structure containing the schema version information.

• SecurityConfiguration

  Specifies a security configuration.

• Segment

  Defines a non-overlapping region of a table's partitions, allowing multiple requests to be run in parallel.

• SelectFields

  Specifies a transform that chooses the data property keys that you want to keep.

• SelectFromCollection

  Specifies a transform that chooses one DynamicFrame from a collection of DynamicFrames. The output is the selected DynamicFrame

• SerDeInfo

  Information about a serialization/deserialization program (SerDe) that serves as an extractor and loader.

• Session

  The period in which a remote Spark runtime environment is running.

• SessionCommand

  The SessionCommand that runs the job.

• SkewedInfo

  Specifies skewed values in a table. Skewed values are those that occur with very high frequency.

• SnowflakeNodeData

  Specifies configuration for Snowflake nodes in Glue Studio.

• SnowflakeSource

  Specifies a Snowflake data source.

• SnowflakeTarget

  Specifies a Snowflake target.

• SortCriterion

  Specifies a field to sort by and a sort order.

• SourceControlDetails

  The details for a source control configuration for a job, allowing synchronization of job artifacts to or from a remote repository.

• SparkConnectorSource

  Specifies a connector to an Apache Spark data source.

• SparkConnectorTarget

  Specifies a target that uses an Apache Spark connector.

• SparkSql

  Specifies a transform where you enter a SQL query using Spark SQL syntax to transform the data. The output is a single DynamicFrame.

• Spigot

  Specifies a transform that writes samples of the data to an Amazon S3 bucket.

• SplitFields

  Specifies a transform that splits data property keys into two DynamicFrames. The output is a collection of DynamicFrames: one with selected data property keys, and one with the remaining data property keys.

• SqlAlias

  Represents a single entry in the list of values for SqlAliases.

• StartingEventBatchCondition

  The batch condition that started the workflow run. Either the number of events in the batch size arrived, in which case the BatchSize member is non-zero, or the batch window expired, in which case the BatchWindow member is non-zero.

• Statement

  The statement or request for a particular action to occur in a session.

• StatementOutput

  The code execution output in JSON format.

• StatementOutputData

  The code execution output in JSON format.

• StorageDescriptor

  Describes the physical storage of table data.

• StreamingDataPreviewOptions

  Specifies options related to data preview for viewing a sample of your data.

• StringColumnStatisticsData

  Defines column statistics supported for character sequence data values.

• Table

  Represents a collection of related data organized in columns and rows.

• TableError

  An error record for table operations.

• TableIdentifier

  A structure that describes a target table for resource linking.

• TableInput

  A structure used to define a table.

• TableVersion

  Specifies a version of a table.

• TableVersionError

  An error record for table-version operations.

• TaskRun

  The sampling parameters that are associated with the machine learning transform.

• TaskRunFilterCriteria

  The criteria that are used to filter the task runs for the machine learning transform.

• TaskRunProperties

  The configuration properties for the task run.

• TaskRunSortCriteria

  The sorting criteria that are used to sort the list of task runs for the machine learning transform.

• TransformConfigParameter

  Specifies the parameters in the config file of the dynamic transform.

• TransformEncryption

  The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS.

• TransformFilterCriteria

  The criteria used to filter the machine learning transforms.

• TransformParameters

  The algorithm-specific parameters that are associated with the machine learning transform.

• TransformSortCriteria

  The sorting criteria that are associated with the machine learning transform.

• Trigger

  Information about a specific trigger.

• TriggerNodeDetails

  The details of a Trigger node present in the workflow.

• TriggerUpdate

  A structure used to provide information used to update a trigger. This object updates the previous trigger definition by overwriting it completely.

• UnfilteredPartition

  A partition that contains unfiltered metadata.

• Union

  Specifies a transform that combines the rows from two or more datasets into a single result.

• UpdateCsvClassifierRequest

  Specifies a custom CSV classifier to be updated.

• UpdateGrokClassifierRequest

  Specifies a grok classifier to update when passed to UpdateClassifier.

• UpdateJsonClassifierRequest

  Specifies a JSON classifier to be updated.

• UpdateXmlClassifierRequest

  Specifies an XML classifier to be updated.

• UpsertRedshiftTargetOptions

  The options to configure an upsert operation when writing to a Redshift target .

• UserDefinedFunction

  Represents the equivalent of a Hive user-defined function (UDF) definition.

• UserDefinedFunctionInput

  A structure used to create or update a user-defined function.

• Workflow

  A workflow is a collection of multiple dependent Glue jobs and crawlers that are run to complete a complex ETL task. A workflow manages the execution and monitoring of all its jobs and crawlers.

• WorkflowGraph

  A workflow graph represents the complete workflow containing all the Glue components present in the workflow and all the directed connections between them.

• WorkflowRun

  A workflow run is an execution of a workflow providing all the runtime information.

• WorkflowRunStatistics

  Workflow run statistics provides statistics about the workflow run.

• XmlClassifier

  A classifier for XML content.

Enums

• AdditionalOptionKeys
  When writing a match expression against AdditionalOptionKeys, 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.
• AggFunction
  When writing a match expression against AggFunction, 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.
• BackfillErrorCode
  When writing a match expression against BackfillErrorCode, 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.
• BlueprintRunState
  When writing a match expression against BlueprintRunState, 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.
• BlueprintStatus
  When writing a match expression against BlueprintStatus, 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.
• CatalogEncryptionMode
  When writing a match expression against CatalogEncryptionMode, 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.
• CloudWatchEncryptionMode
  When writing a match expression against CloudWatchEncryptionMode, 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.
• ColumnStatisticsType
  When writing a match expression against ColumnStatisticsType, 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.
• Comparator
  When writing a match expression against Comparator, 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.
• Compatibility
  When writing a match expression against Compatibility, 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.
• CompressionType
  When writing a match expression against CompressionType, 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.
• ConnectionPropertyKey
  When writing a match expression against ConnectionPropertyKey, 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.
• ConnectionType
  When writing a match expression against ConnectionType, 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.
• CrawlState
  When writing a match expression against CrawlState, 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.
• CrawlerHistoryState
  When writing a match expression against CrawlerHistoryState, 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.
• CrawlerLineageSettings
  When writing a match expression against CrawlerLineageSettings, 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.
• CrawlerState
  When writing a match expression against CrawlerState, 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.
• CsvHeaderOption
  When writing a match expression against CsvHeaderOption, 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.
• DataFormat
  When writing a match expression against DataFormat, 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.
• DataQualityRuleResultStatus
  When writing a match expression against DataQualityRuleResultStatus, 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.
• DeleteBehavior
  When writing a match expression against DeleteBehavior, 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.
• DeltaTargetCompressionType
  When writing a match expression against DeltaTargetCompressionType, 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.
• DqStopJobOnFailureTiming
  When writing a match expression against DqStopJobOnFailureTiming, 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.
• DqTransformOutput
  When writing a match expression against DqTransformOutput, 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.
• EnableHybridValues
  When writing a match expression against EnableHybridValues, 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.
• ExecutionClass
  When writing a match expression against ExecutionClass, 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.
• ExistCondition
  When writing a match expression against ExistCondition, 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.
• FederationSourceErrorCode
  When writing a match expression against FederationSourceErrorCode, 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.
• FieldName
  When writing a match expression against FieldName, 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.
• FilterLogicalOperator
  When writing a match expression against FilterLogicalOperator, 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.
• FilterOperation
  When writing a match expression against FilterOperation, 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.
• FilterOperator
  When writing a match expression against FilterOperator, 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.
• FilterValueType
  When writing a match expression against FilterValueType, 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.
• GlueRecordType
  When writing a match expression against GlueRecordType, 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.
• HudiTargetCompressionType
  When writing a match expression against HudiTargetCompressionType, 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.
• JdbcConnectionType
  When writing a match expression against JdbcConnectionType, 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.
• JdbcDataType
  When writing a match expression against JdbcDataType, 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.
• JdbcMetadataEntry
  When writing a match expression against JdbcMetadataEntry, 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.
• JobBookmarksEncryptionMode
  When writing a match expression against JobBookmarksEncryptionMode, 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.
• JobRunState
  When writing a match expression against JobRunState, 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.
• JoinType
  When writing a match expression against JoinType, 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.
• Language
  When writing a match expression against Language, 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.
• LastCrawlStatus
  When writing a match expression against LastCrawlStatus, 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.
• Logical
  When writing a match expression against Logical, 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.
• LogicalOperator
  When writing a match expression against LogicalOperator, 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.
• MetadataOperation
  When writing a match expression against MetadataOperation, 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.
• MlUserDataEncryptionModeString
  When writing a match expression against MlUserDataEncryptionModeString, 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.
• ParamType
  When writing a match expression against ParamType, 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.
• ParquetCompressionType
  When writing a match expression against ParquetCompressionType, 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.
• PartitionIndexStatus
  When writing a match expression against PartitionIndexStatus, 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.
• Permission
  When writing a match expression against Permission, 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.
• PermissionType
  When writing a match expression against PermissionType, 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.
• PiiType
  When writing a match expression against PiiType, 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.
• QuoteChar
  When writing a match expression against QuoteChar, 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.
• RecrawlBehavior
  When writing a match expression against RecrawlBehavior, 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.
• RegistryStatus
  When writing a match expression against RegistryStatus, 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.
• ResourceShareType
  When writing a match expression against ResourceShareType, 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.
• S3EncryptionMode
  When writing a match expression against S3EncryptionMode, 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.
• ScheduleState
  When writing a match expression against ScheduleState, 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.
• SchemaDiffType
  When writing a match expression against SchemaDiffType, 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.
• SchemaStatus
  When writing a match expression against SchemaStatus, 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.
• SchemaVersionStatus
  When writing a match expression against SchemaVersionStatus, 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.
• Separator
  When writing a match expression against Separator, 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.
• SessionStatus
  When writing a match expression against SessionStatus, 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.
• Sort
  When writing a match expression against Sort, 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.
• SortDirectionType
  When writing a match expression against SortDirectionType, 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.
• SourceControlAuthStrategy
  When writing a match expression against SourceControlAuthStrategy, 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.
• SourceControlProvider
  When writing a match expression against SourceControlProvider, 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.
• StartingPosition
  When writing a match expression against StartingPosition, 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.
• StatementState
  When writing a match expression against StatementState, 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.
• TargetFormat
  When writing a match expression against TargetFormat, 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.
• TaskRunSortColumnType
  When writing a match expression against TaskRunSortColumnType, 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.
• TaskStatusType
  When writing a match expression against TaskStatusType, 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.
• TaskType
  When writing a match expression against TaskType, 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.
• TransformSortColumnType
  When writing a match expression against TransformSortColumnType, 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.
• TransformStatusType
  When writing a match expression against TransformStatusType, 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.
• TransformType
  When writing a match expression against TransformType, 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.
• TriggerState
  When writing a match expression against TriggerState, 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.
• TriggerType
  When writing a match expression against TriggerType, 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.
• UnionType
  When writing a match expression against UnionType, 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.
• UpdateBehavior
  When writing a match expression against UpdateBehavior, 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.
• UpdateCatalogBehavior
  When writing a match expression against UpdateCatalogBehavior, 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.
• WorkerType
  When writing a match expression against WorkerType, 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.
• WorkflowRunStatus
  When writing a match expression against WorkflowRunStatus, 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.