Expand description
Data structures used by operation inputs/outputs.
Modules§
Structs§
- Accept
Choice Specifies the prediction (aka, the automatically generated piece of metadata) and the target (for example, a column name) that can be accepted.
- Accept
Rule Specifies the rule and the threshold under which a prediction can be accepted.
- Accepted
Asset Scope The accepted asset scope.
- Account
Info The account information within an account pool.
- Account
Pool Summary The summary of the account pool.
- AddTo
Project Member Pool Policy Grant Detail The details of the policy grant.
- Aggregation
List Item An aggregation list item.
- Aggregation
Output The aggregation for an attribute.
- Aggregation
Output Item An aggregation output item.
- AllDomain
Units Grant Filter The grant filter for all domain units.
- AllUsers
Grant Filter The all users grant filter.
- Asset
Filter Summary The summary of the asset filter.
- Asset
InData Product Listing Item The listing of the asset in a data product.
- Asset
Item A Amazon DataZone inventory asset.
- Asset
Item Additional Attributes The additional attributes of an inventory asset.
- Asset
Listing An asset published in an Amazon DataZone catalog.
- Asset
Listing Details The details of an asset published in an Amazon DataZone catalog.
- Asset
Listing Item The details of an asset published in an Amazon DataZone catalog.
- Asset
Listing Item Additional Attributes Additional attributes of an inventory asset.
- Asset
Revision The revision of an inventory asset.
- Asset
Scope The asset scope.
- Asset
Target Name Map The name map for assets.
- Asset
Type Item The details of the asset type.
- Asset
Types ForRule The asset type for the rule details.
- Athena
Properties Input The Amazon Athena properties of a connection.
- Athena
Properties Output The Amazon Athena properties of a connection.
- Athena
Properties Patch The Amazon Athena properties patch of a connection.
- Authentication
Configuration The authentication configuration of a connection.
- Authentication
Configuration Input The authentication configuration of a connection.
- Authentication
Configuration Patch The authentication configuration patch of a connection.
- Authorization
Code Properties The authorization code properties of a connection.
- AwsConsole
Link Parameters The parameters of the console link specified as part of the environment action.
- AwsLocation
The location of a project.
- Basic
Authentication Credentials The basic authentication credentials of a connection.
- Business
Name Generation Configuration The configuration of the business name generation.
- Cloud
Formation Properties Part of the provisioning properties of the environment blueprint.
- Column
Filter Configuration The column configuration of the asset filter.
- Configurable
Action Parameter The details of the parameters for the configurable environment action.
- Configurable
Environment Action The configurable action of a Amazon DataZone environment.
- Connection
Credentials The credentials of a connection.
- Connection
Summary The summary of a connection.
- Create
Asset Type Policy Grant Detail The details of the policy grant.
- Create
Domain Unit Policy Grant Detail The details of the policy grant.
- Create
Environment Profile Policy Grant Detail The details of the policy grant.
- Create
Form Type Policy Grant Detail The details of the policy grant.
- Create
Glossary Policy Grant Detail The details of the policy grant.
- Create
Project From Project Profile Policy Grant Detail Specifies whether to create a project from project profile policy grant details.
- Create
Project Policy Grant Detail The details of the policy grant.
- Custom
Account Pool Handler The custom Amazon Web Services Lambda handler within an account pool.
- Custom
Parameter The details of user parameters of an environment blueprint.
- Data
Product Item The data product.
- Data
Product Item Additional Attributes The additional attributes of an Amazon DataZone data product.
- Data
Product Listing The data product listing.
- Data
Product Listing Item The asset of the data product listing.
- Data
Product Listing Item Additional Attributes The additional attributes of the asset of the data product.
- Data
Product Result Item The data product.
- Data
Product Revision The data product revision.
- Data
Source Error Message The details of the error message that is returned if the operation cannot be successfully completed.
- Data
Source RunActivity The activity details of the data source run.
- Data
Source RunLineage Summary The run lineage summary of a data source.
- Data
Source RunSummary The details of a data source run.
- Data
Source Summary The details of the data source.
- Deployment
The details of the last deployment of the environment.
- Deployment
Properties The deployment properties of the Amazon DataZone blueprint.
- Detailed
Glossary Term Details of a glossary term attached to the inventory asset.
- Domain
Summary A summary of a Amazon DataZone domain.
- Domain
Unit Filter ForProject The domain unit filter of the project grant filter.
- Domain
Unit Group Properties The properties of a domain unit group.
- Domain
Unit Policy Grant Principal The domain unit principal to whom the policy is granted.
- Domain
Unit Summary The summary of the domain unit.
- Domain
Unit Target The target for the domain unit.
- Domain
Unit User Properties The properties of the domain unit user.
- Environment
Action Summary The details about the specified action configured for an environment. For example, the details of the specified console links for an analytics tool that is available in this environment.
- Environment
Blueprint Configuration Item The configuration details of an environment blueprint.
- Environment
Blueprint Summary The details of an environment blueprint summary.
- Environment
Configuration The configuration of an environment.
- Environment
Configuration Parameter The environment configuration parameter.
- Environment
Configuration Parameters Details The details of the environment configuration parameter.
- Environment
Configuration User Parameter The environment configuration user parameters.
- Environment
Deployment Details The environment deployment details.
- Environment
Error The failure reasons for the environment deployment.
- Environment
Parameter The parameter details of an evironment profile.
- Environment
Profile Summary The details of an environment profile.
- Environment
Resolved Account Specifies the account/Region that is to be used during project creation for a particular blueprint.
- Environment
Summary The details of an environment.
- Equal
ToExpression Specifies whether the value is equal to an expression.
- Failure
Cause Specifies the error message that is returned if the operation cannot be successfully completed.
- Filter
A search filter in Amazon DataZone.
- Filter
Expression A filter expression in Amazon DataZone.
- Form
Entry Input The details of the form entry.
- Form
Entry Output The details of the form entry.
- Form
Input The details of a metadata form.
- Form
Output The details of a metadata form.
- Form
Type Data The details of the metadata form type.
- Glossary
Item The details of a business glossary.
- Glossary
Item Additional Attributes The additional attributes of an Amazon DataZone glossary.
- Glossary
Term Item The details of a business glossary term.
- Glossary
Term Item Additional Attributes The additional attributes of an Amazon DataZone glossary term.
- Glue
Connection The Amazon Web Services Glue connection.
- Glue
Connection Input The Amazon Web Services Glue connecton input.
- Glue
Connection Patch The Amazon Web Services Glue connection patch.
- GlueO
Auth2 Credentials The GlueOAuth2 credentials of a connection.
- Glue
Properties Input The Amazon Web Services Glue properties of a connection.
- Glue
Properties Output The properties of the Amazon Web Services Glue connection.
- Glue
Properties Patch The Amazon Web Services Glue properties patch of a connection.
- Glue
RunConfiguration Input The configuration details of the Amazon Web Services Glue data source.
- Glue
RunConfiguration Output The configuration details of the Amazon Web Services Glue data source.
- Glue
Self Grant Status Output The details of the self granting status.
- Greater
Than Expression Specifies whether the value is greater than an expression.
- Greater
Than OrEqual ToExpression Specifies whether the value is greater than or equal to an expression.
- Group
Details The details of a group in Amazon DataZone.
- Group
Profile Summary The details of a group profile.
- Hyper
PodProperties Input The hyper pod properties of a Amazon Web Services Glue properties patch.
- Hyper
PodProperties Output The hyper pod properties of a Amazon Web Services Glue properties patch.
- IamProperties
Input The IAM properties of a connection.
- IamProperties
Output The IAM properties of a connection.
- IamProperties
Patch The IAM properties patch of a connection.
- IamUser
Profile Details The details of an IAM user profile in Amazon DataZone.
- Import
The details of the import of the metadata form type.
- InExpression
Specifies whether values are in the expression.
- IsNot
Null Expression Specifies that the expression is not null.
- IsNull
Expression Specifies that the expression is null.
- JobRun
Error The job run error.
- JobRun
Summary The job run summary.
- Lake
Formation Configuration The Lake Formation configuration of the Data Lake blueprint.
- Less
Than Expression Specifies that a value is less than an expression.
- Less
Than OrEqual ToExpression Specifies that a value is less than or equal to an expression.
- Like
Expression Specifies that a value is like the expression.
- Lineage
Event Summary The data lineage event summary.
- Lineage
Info The data lineage information.
- Lineage
Node Reference The reference details for the data lineage node.
- Lineage
Node Summary The summary of the data lineage node.
- Lineage
Node Type Item The details of a data lineage node type.
- Lineage
RunDetails The data lineage run details.
- Lineage
SqlQuery RunDetails The SQL query run details of a data lineage run.
- Lineage
Sync Schedule The lineage sync schedule.
- Listing
Revision A revision of an asset published in a Amazon DataZone catalog.
- Listing
Revision Input A revision to be made to an asset published in a Amazon DataZone catalog.
- Listing
Summary The summary of the listing of the data product.
- Listing
Summary Item The results of the data product summary.
- Match
Offset The offset of a matched term.
- Metadata
Form Enforcement Detail The enforcement details of a metadata form.
- Metadata
Form Reference The reference of a metadata form.
- Metadata
Form Summary The summary of the metadata form.
- Metadata
Generation RunItem The metadata generation run.
- Metadata
Generation RunTarget The asset for which metadata was generated.
- Name
Identifier The name identifier.
- NotEqual
ToExpression Specifies that a value is not equal to the expression.
- NotIn
Expression Specifies that a value is not in the expression.
- NotLike
Expression Specifies that a value might be not like the expression.
- Notification
Output The details of a notification generated in Amazon DataZone.
- Notification
Resource The details of the resource mentioned in a notification.
- OAuth2
Client Application The OAuth2Client application.
- OAuth2
Properties The OAuth2 properties.
- Open
Lineage RunEvent Summary The open lineage run event summary.
- Override
Domain Unit Owners Policy Grant Detail The grant details of the override domain unit owners policy.
- Override
Project Owners Policy Grant Detail The details of the override project owners policy grant.
- Owner
Group Properties The properties of the domain unit owners group.
- Owner
Group Properties Output The properties of the domain unit owners group.
- Owner
User Properties The properties of the owner user.
- Owner
User Properties Output The properties of the owner user.
- Physical
Connection Requirements Physical connection requirements of a connection.
- Physical
Endpoint The physical endpoints of a connection.
- Policy
Grant Member A member of the policy grant list.
- Prediction
Configuration The configuration of the prediction.
- Project
Deletion Error Specifies the error message that is returned if the operation cannot be successfully completed.
- Project
Member The details of a project member.
- Project
Policy Grant Principal The project policy grant principal.
- Project
Profile Summary The summary of a project profile.
- Project
Summary The details of a Amazon DataZone project.
- Projects
ForRule Specifies projects in which the rule is created.
- Recommendation
Configuration The recommendation to be updated as part of the
UpdateDataSourceaction.- Redshift
Cluster Storage The details of the Amazon Redshift cluster storage.
- Redshift
Credential Configuration The details of the credentials required to access an Amazon Redshift cluster.
- Redshift
Lineage Sync Configuration Input The Amaon Redshift lineage sync configuration.
- Redshift
Lineage Sync Configuration Output The Amaon Redshift lineage sync configuration.
- Redshift
Properties Input The Amazon Redshift properties.
- Redshift
Properties Output The Amazon Redshift properties.
- Redshift
Properties Patch Amazon Redshift properties patch.
- Redshift
RunConfiguration Input The configuration details of the Amazon Redshift data source.
- Redshift
RunConfiguration Output The configuration details of the Amazon Redshift data source.
- Redshift
Self Grant Status Output The details for the self granting status for an Amazon Redshift data source.
- Redshift
Serverless Storage The details of the Amazon Redshift Serverless workgroup storage.
- Reject
Choice The details of the automatically generated business metadata that is rejected.
- Reject
Rule Specifies the rule and the threshold under which a prediction can be rejected.
- Relational
Filter Configuration The relational filter configuration for the data source.
- Resource
The details of a provisioned resource of this Amazon DataZone environment.
- RowFilter
Configuration The row filter configuration details.
- Rule
Scope The scope of a rule.
- Rule
Summary The summary of the rule.
- RunStatistics
ForAssets The asset statistics from the data source run.
- S3Properties
Input The Amazon S3 properties of a connection.
- S3Properties
Output The Amazon S3 properties of a connection.
- S3Properties
Patch The Amazon S3 properties patch of a connection.
- Sage
Maker RunConfiguration Input The Amazon SageMaker run configuration.
- Sage
Maker RunConfiguration Output The Amazon SageMaker run configuration.
- Schedule
Configuration The details of the schedule of the data source runs.
- Search
InItem The details of the search.
- Search
Sort The details of the way to sort search results.
- Self
Grant Status Detail The details for the self granting status.
- Single
Sign On The single sign-on details in Amazon DataZone.
- Spark
EmrProperties Input The Spark EMR properties.
- Spark
EmrProperties Output The Spark EMR properties.
- Spark
EmrProperties Patch The Spark EMR properties patch.
- Spark
Glue Args The Spark Amazon Web Services Glue args.
- Spark
Glue Properties Input The Spark Amazon Web Services Glue properties.
- Spark
Glue Properties Output The Spark Amazon Web Services Glue properties.
- SsoUser
Profile Details The single sign-on details of the user profile.
- Subscribed
Asset The details of the asset for which the subscription grant is created.
- Subscribed
Asset Listing The details of the published asset for which the subscription grant is created.
- Subscribed
Listing The details of the published asset for which the subscription grant is created.
- Subscribed
Listing Input The published asset for which the subscription grant is to be created.
- Subscribed
Product Listing The data product listing.
- Subscribed
Project The project that has the subscription grant.
- Subscribed
Project Input The project that is to be given a subscription grant.
- Subscription
Grant Summary The details of the subscription grant.
- Subscription
Request Summary The details of the subscription request.
- Subscription
Summary The details of the subscription.
- Subscription
Target Form The details of the subscription target configuration.
- Subscription
Target Summary The details of the subscription target.
- Term
Relations The details of the term relations.
- Text
Match Item A structure indicating matched terms for an attribute.
- Time
Series Data Point Form Input The time series data points form.
- Time
Series Data Point Form Output The time series data points form.
- Time
Series Data Point Summary Form Output The summary of the time series data points form.
- Topic
The topic of the notification.
- Unit
The details of the policy of creating an environment.
- UseAsset
Type Policy Grant Detail Specifies the domain unit(s) whose projects can use this asset type while creating asset or asset revisions.
- User
Details The user details of a project member.
- User
Profile Summary The details of the user profile.
- Username
Password The username and password of a connection.
Enums§
- Accept
Rule Behavior - When writing a match expression against
AcceptRuleBehavior, 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. - Account
Source The source of accounts for the account pool. In the current release, it's either a static list of accounts provided by the customer or a custom Amazon Web Services Lambda handler.
- Action
Parameters The parameters of the environment action.
- Asset
Filter Configuration The configuration details of the asset filter.
- Auth
Type - When writing a match expression against
AuthType, 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. - Authentication
Type - When writing a match expression against
AuthenticationType, 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. - AwsAccount
The account ID of a project.
- Change
Action - When writing a match expression against
ChangeAction, 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. - Compute
Environments - When writing a match expression against
ComputeEnvironments, 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. - Configurable
Action Type Authorization - When writing a match expression against
ConfigurableActionTypeAuthorization, 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. - Connection
Properties Input The properties of a connection.
- Connection
Properties Output The properties of a connection.
- Connection
Properties Patch The connection properties patch.
- Connection
Status - When writing a match expression against
ConnectionStatus, 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. - Connection
Type - 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. - Data
Asset Activity Status - When writing a match expression against
DataAssetActivityStatus, 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. - Data
Product Item Type - When writing a match expression against
DataProductItemType, 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. - Data
Product Status - When writing a match expression against
DataProductStatus, 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. - Data
Source Configuration Input The configuration of the data source.
- Data
Source Configuration Output The configuration of the data source.
- Data
Source Error Type - When writing a match expression against
DataSourceErrorType, 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. - Data
Source RunStatus - When writing a match expression against
DataSourceRunStatus, 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. - Data
Source RunType - When writing a match expression against
DataSourceRunType, 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. - Data
Source Status - 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. - Data
Zone Entity Type - When writing a match expression against
DataZoneEntityType, 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. - Deployment
Mode - When writing a match expression against
DeploymentMode, 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. - Deployment
Status - 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. - Deployment
Type - When writing a match expression against
DeploymentType, 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. - Domain
Status - When writing a match expression against
DomainStatus, 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. - Domain
Unit Designation - When writing a match expression against
DomainUnitDesignation, 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. - Domain
Unit Grant Filter The grant filter for the domain unit. In the current release of Amazon DataZone, the only supported filter is the
allDomainUnitsGrantFilter.- Domain
Unit Owner Properties The properties of the domain unit owner.
- Domain
Version - When writing a match expression against
DomainVersion, 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. - Edge
Direction - When writing a match expression against
EdgeDirection, 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. - Enable
Setting - When writing a match expression against
EnableSetting, 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. - Entity
Type - When writing a match expression against
EntityType, 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. - Environment
Status - When writing a match expression against
EnvironmentStatus, 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. - Event
Summary The event summary.
- Filter
Clause A search filter clause in Amazon DataZone.
- Filter
Expression Type - When writing a match expression against
FilterExpressionType, 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. - Filter
Status - When writing a match expression against
FilterStatus, 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. - Form
Type Status - When writing a match expression against
FormTypeStatus, 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. - Glossary
Status - When writing a match expression against
GlossaryStatus, 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. - Glossary
Term Status - When writing a match expression against
GlossaryTermStatus, 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. - Glossary
Usage Restriction - When writing a match expression against
GlossaryUsageRestriction, 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. - Glue
Connection Type - When writing a match expression against
GlueConnectionType, 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. - Governance
Type - When writing a match expression against
GovernanceType, 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. - Governed
Entity Type - When writing a match expression against
GovernedEntityType, 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. - Granted
Entity The details of a listing for which a subscription is granted.
- Granted
Entity Input The details of a listing for which a subscription is to be granted.
- Group
Policy Grant Principal The group principal to whom the policy is granted.
- Group
Profile Status - When writing a match expression against
GroupProfileStatus, 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. - Group
Search Type - When writing a match expression against
GroupSearchType, 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. - Hyper
PodOrchestrator - When writing a match expression against
HyperPodOrchestrator, 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. - Inventory
Search Scope - When writing a match expression against
InventorySearchScope, 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. - JobRun
Details The details of a job run.
- JobRun
Mode - When writing a match expression against
JobRunMode, 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. - JobRun
Status - When writing a match expression against
JobRunStatus, 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. - JobType
- When writing a match expression against
JobType, 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. - Lineage
Event Processing Status - When writing a match expression against
LineageEventProcessingStatus, 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. - Lineage
Import Status - When writing a match expression against
LineageImportStatus, 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. - Listing
Item The details of a listing (aka asset published in a Amazon DataZone catalog).
- Listing
Status - When writing a match expression against
ListingStatus, 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. - Managed
Policy Type - When writing a match expression against
ManagedPolicyType, 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. - Match
Rationale Item A rationale indicating why this item was matched by search.
- Member
The details about a project member.
- Member
Details The details about a project member.
- Metadata
Generation RunStatus - When writing a match expression against
MetadataGenerationRunStatus, 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. - Metadata
Generation RunType - When writing a match expression against
MetadataGenerationRunType, 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. - Metadata
Generation Target Type - When writing a match expression against
MetadataGenerationTargetType, 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. - Model
The model of the API.
- Notification
Resource Type - When writing a match expression against
NotificationResourceType, 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. - Notification
Role - When writing a match expression against
NotificationRole, 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. - Notification
Type - When writing a match expression against
NotificationType, 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. - OAuth2
Grant Type - When writing a match expression against
OAuth2GrantType, 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. - Open
Lineage RunState - When writing a match expression against
OpenLineageRunState, 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. - Overall
Deployment Status - When writing a match expression against
OverallDeploymentStatus, 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. - Owner
Properties The properties of a domain unit's owner.
- Owner
Properties Output The ID of the domain unit owners group.
- Policy
Grant Detail The details of the policy grant.
- Policy
Grant Principal The policy grant principal.
- Project
Designation - When writing a match expression against
ProjectDesignation, 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. - Project
Grant Filter The project grant filter.
- Project
Status - When writing a match expression against
ProjectStatus, 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. - Protocol
- When writing a match expression against
Protocol, 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. - Provisioning
Configuration The provisioning configuration of the blueprint.
- Provisioning
Properties The provisioning properties of an environment blueprint.
- Redshift
Credentials Amazon Redshift credentials of a connection.
- Redshift
Storage The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run.
- Redshift
Storage Properties The Amazon Redshift storage properties.
- Region
The Amazon Web Services Region.
- Reject
Rule Behavior - When writing a match expression against
RejectRuleBehavior, 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. - Resolution
Strategy - When writing a match expression against
ResolutionStrategy, 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. - RowFilter
The row filter.
- RowFilter
Expression The row filter expression.
- Rule
Action - When writing a match expression against
RuleAction, 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. - Rule
Detail The details of a rule.
- Rule
Scope Selection Mode - When writing a match expression against
RuleScopeSelectionMode, 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. - Rule
Target The target of the rule.
- Rule
Target Type - When writing a match expression against
RuleTargetType, 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. - Rule
Type - When writing a match expression against
RuleType, 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. - Search
Inventory Result Item The details of the search results.
- Search
Output Additional Attribute - When writing a match expression against
SearchOutputAdditionalAttribute, 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. - Search
Result Item The details of the results of the
SearchListingsaction.- Search
Types Result Item The details of the results of the
SearchTypesaction.- Self
Grant Status - When writing a match expression against
SelfGrantStatus, 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. - Self
Grant Status Output The details for the self granting status for a data source.
- Sort
Field Account Pool - When writing a match expression against
SortFieldAccountPool, 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
Field Connection - When writing a match expression against
SortFieldConnection, 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
Field Project - When writing a match expression against
SortFieldProject, 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. - SortKey
- When writing a match expression against
SortKey, 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
Order - When writing a match expression against
SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Status
- When writing a match expression against
Status, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Subscribed
Listing Item The published asset for which the subscription grant is created.
- Subscribed
Principal The principal that has the subscription grant for the asset.
- Subscribed
Principal Input The principal that is to be given a subscriptiong grant.
- Subscription
Grant Overall Status - When writing a match expression against
SubscriptionGrantOverallStatus, 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. - Subscription
Grant Status - When writing a match expression against
SubscriptionGrantStatus, 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. - Subscription
Request Status - When writing a match expression against
SubscriptionRequestStatus, 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. - Subscription
Status - When writing a match expression against
SubscriptionStatus, 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. - Target
Entity Type - When writing a match expression against
TargetEntityType, 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. - Task
Status - When writing a match expression against
TaskStatus, 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. - Time
Series Entity Type - When writing a match expression against
TimeSeriesEntityType, 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. - Timezone
- When writing a match expression against
Timezone, 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. - Types
Search Scope - When writing a match expression against
TypesSearchScope, 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. - User
Assignment - When writing a match expression against
UserAssignment, 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. - User
Designation - When writing a match expression against
UserDesignation, 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. - User
Policy Grant Principal The user policy grant principal.
- User
Profile Details The details of the user profile in Amazon DataZone.
- User
Profile Status - When writing a match expression against
UserProfileStatus, 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. - User
Profile Type - When writing a match expression against
UserProfileType, 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. - User
Search Type - When writing a match expression against
UserSearchType, 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. - User
Type - When writing a match expression against
UserType, 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.