diff --git a/.github/workflows/configs.yml b/.github/workflows/configs.yml index eb18f3a4..eb12a352 100644 --- a/.github/workflows/configs.yml +++ b/.github/workflows/configs.yml @@ -75,7 +75,7 @@ jobs: WORKING_DIR: 'src' RUST_TOOLCHAIN: '1.96.0' # keep in sync with src/rust-toolchain.toml NODE_VERSION: '22.x' - PYTHON_VERSION: '3.12' + PYTHON_VERSION: '3.9' GO_VERSION: '1.26' UNIFFI_BINDGEN_GO_TAG: 'v0.7.1+v0.31.0' # keep in sync with bindings-go/README.md and the uniffi pin in bindings-go/Cargo.toml JAVA_VERSION: '21' diff --git a/INSTALLATION.md b/INSTALLATION.md index f895d6d0..bd73f1cd 100644 --- a/INSTALLATION.md +++ b/INSTALLATION.md @@ -53,7 +53,7 @@ See the [Node.js API and examples](src/bindings-wasm/README.md). ### Python Production versions are published to [PyPI](https://pypi.org/project/cloudformation-validate/); prereleases are -published to [TestPyPI](https://test.pypi.org/project/cloudformation-validate/). The package requires Python 3.12 or +published to [TestPyPI](https://test.pypi.org/project/cloudformation-validate/). The package requires Python 3.9 or later, and its platform-specific wheels have no runtime package dependencies. ```bash @@ -95,7 +95,7 @@ See the [Go API and examples](src/bindings-go/README.md). The JVM library is published to [Maven Central as `software.amazon.cloudformation:cloudformation-validate`](https://central.sonatype.com/artifact/software.amazon.cloudformation/cloudformation-validate) -and requires JDK 21 or later. The jar includes native libraries for all supported platforms; Maven or Gradle resolves +and requires Java 8 or later. The jar includes native libraries for all supported platforms; Maven or Gradle resolves JNA, Gson, and the Kotlin standard library. Gradle (Kotlin DSL): @@ -185,7 +185,7 @@ testing the project from source need the tools below. Pinned versions live in | Kotlin (`kotlinc`) | 2.4.0 | JVM binding build | | | `ktlint` | 1.8.0 | JVM binding formatting | | | Gradle | 9.6.1 | JVM binding build/test | Must be on `PATH` - `bindings-jvm/build.sh` and the JVM test runner invoke `gradle` | -| Python | 3.12+ | Python binding build/test, license generation, `scripts/` | `setuptools` for the wheel build; no other packages required | +| Python | 3.9+ | Python binding build/test, license generation, `scripts/` | `setuptools` for the wheel build; no other packages required | | Go | 1.26+ | Go binding build/test | cgo must be enabled (default); Windows also needs `rustup target add x86_64-pc-windows-gnu` and MinGW-w64 `gcc` | | `uniffi-bindgen-go` | 0.7.1 | Go binding generation | `cargo install --git https://github.com/NordSecurity/uniffi-bindgen-go --tag v0.7.1+v0.31.0` | | `git`, `curl`, `openssl` | - | source control, fetching JVM deps, verifying releases | Usually preinstalled | diff --git a/src/bindings-go/README.md b/src/bindings-go/README.md index 34b58ccb..2f6e7828 100644 --- a/src/bindings-go/README.md +++ b/src/bindings-go/README.md @@ -61,6 +61,7 @@ diagnostics for the same template and config. A `nil` config uses only the built | `ValidateStandardFile(path string, config *ValidateConfig)` | `(*StandardReport, error)` | Reads a template from disk, then validates it | | `ValidateDetailed(template []byte, config *ValidateConfig, filePath string)` | `(*DetailedReport, error)` | Validates bytes with documentation URLs, rule descriptions, phase tags, and `ViolationContext` | | `ValidateDetailedFile(path string, config *ValidateConfig)` | `(*DetailedReport, error)` | Reads a template from disk, then validates it (detailed) | +| `ValidateAWSAPIRequest(request AWSAPIRequest, config *ValidateConfig)` | `(*AWSAPIRequestValidation, error)` | Classifies and validates an AWS API request offline | | `ListRules()` | `([]RuleInfo, error)` | Returns metadata for every built-in and loaded custom rule | | `EngineName()` | `string` | `"rego"` or `"cel"` | | `Destroy()` | - | Releases the native engine; the engine must not be used afterwards | @@ -194,6 +195,69 @@ type PseudoParameterOverrides struct { } ``` +## AWS API Request Validation + +Validates an AWS API request by classifying the operation, inferring the CloudFormation resource type, and running +schema and rule validation against a synthesized template - entirely offline. The method returns classification +metadata and an optional `StandardReport` when the request was validated (not skipped for read-only operations). + +```go +engine, _ := cfnvalidate.NewRegoEngine(nil) +defer engine.Destroy() + +result, err := engine.ValidateAWSAPIRequest(cfnvalidate.AWSAPIRequest{ + ServiceName: "s3", + OperationName: "CreateBucket", + Parameters: map[string]any{"Bucket": "my-bucket"}, + HTTPMethod: "PUT", +}, nil) +if err != nil { + log.Fatal(err) +} +fmt.Printf("Kind: %s Status: %s Types: %v\n", + result.OperationKind, result.Status, result.ResourceTypes) +if result.Report != nil { + for _, d := range result.Report.Diagnostics { + fmt.Printf(" [%s] %s: %s\n", d.Severity, d.RuleID, d.Message) + } +} +``` + +### AWSAPIRequest + +```go +type AWSAPIRequest struct { + ServiceName string // AWS service (e.g. "s3", "DynamoDb") - case-insensitive + OperationName string // operation name (e.g. "CreateBucket") - case-sensitive + Parameters map[string]any // request parameters: strings, numbers, booleans, []byte, maps, slices, nil + ServicePrefix string // optional signing prefix (e.g. "cloudcontrolapi") + HTTPMethod string // optional HTTP method hint for classification + IsReadOnly *bool // explicit read-only flag - skips validation when true +} +``` + +`Parameters` values are recursively encoded into the core's tagged value representation. Supported Go types: `nil`, +`bool`, all signed/unsigned integer widths, `float32`/`float64` (finite only), `string`, `[]byte` (as byte arrays), +`time.Time` (as an RFC 3339 UTC string), `json.Number`, slices/arrays, and `map[string]any`. Integer-valued +`json.Number` inputs are preserved across the full signed and unsigned 64-bit range; integer literals outside that range +are represented as unsupported rather than rounded through `float64`. SDK-defined type aliases (e.g. +`types.InstanceType` which is `type InstanceType string`) are handled transparently via their underlying kind. +Non-finite floats, maps with non-string keys, and unsupported types are represented as `UNSUPPORTED` rather than +coerced. + +### AWSAPIRequestValidation + +```go +type AWSAPIRequestValidation struct { + OperationKind AWSAPIOperationKind // READ_ONLY, CLOUD_FORMATION_CREATE, etc. + Status AWSAPIRequestValidationStatus // VALIDATED or SKIPPED + TemplateSource *AWSAPITemplateSource // TEMPLATE_BODY, SYNTHESIZED_CREATE, etc. + ResourceTypes []string // inferred CloudFormation resource types + Reason string // human-readable explanation + Report *StandardReport // present only when Status is VALIDATED +} +``` + ## TemplateModel Parses a template into the resolved `SemanticModel` for direct inspection - the same model the engines evaluate rules diff --git a/src/bindings-go/go/cfnvalidate.go b/src/bindings-go/go/cfnvalidate.go index 3a2e0d2c..887fdf37 100644 --- a/src/bindings-go/go/cfnvalidate.go +++ b/src/bindings-go/go/cfnvalidate.go @@ -21,7 +21,12 @@ package cfnvalidate import ( "encoding/json" "fmt" + "math" "os" + "reflect" + "strconv" + "strings" + "time" bindings "github.com/aws-cloudformation/cloudformation-validate/src/bindings-go/go/internal/bindings_go" ) @@ -77,6 +82,7 @@ func decodeInto[T any](data string, what string) (*T, error) { type nativeEngine interface { ValidateStandardJson(template []byte, optionsJson string, filePath string) (string, error) ValidateDetailedJson(template []byte, optionsJson string, filePath string) (string, error) + ValidateAwsApiRequestJson(requestJson string, optionsJson string) (string, error) ListRulesJson() (string, error) EngineName() string Destroy() @@ -195,6 +201,196 @@ func (e *Engine) Destroy() { e.inner.Destroy() } +// ValidateAWSAPIRequest classifies and validates an AWS API request against +// CloudFormation schemas and rules entirely offline. The result contains +// operation classification, resource type inference, and an optional +// StandardReport when the request was validated (not skipped). +func (e *Engine) ValidateAWSAPIRequest(request AWSAPIRequest, config *ValidateConfig) (*AWSAPIRequestValidation, error) { + optionsJSON, err := validateConfigJSON(config) + if err != nil { + return nil, err + } + requestJSON, err := marshalAWSAPIRequest(request) + if err != nil { + return nil, err + } + data, err := e.inner.ValidateAwsApiRequestJson(requestJSON, optionsJSON) + if err != nil { + return nil, err + } + return decodeInto[AWSAPIRequestValidation](data, "AWS API request validation") +} + +// marshalAWSAPIRequest encodes an AWSAPIRequest into the wire JSON that the +// Rust side expects, converting Go parameter values into tagged AwsApiValue +// objects. +func marshalAWSAPIRequest(request AWSAPIRequest) (string, error) { + wire := awsApiRequestWire{ + ServiceName: request.ServiceName, + OperationName: request.OperationName, + Parameters: make(map[string]awsApiValue, len(request.Parameters)), + ServicePrefix: nilIfEmpty(request.ServicePrefix), + HTTPMethod: nilIfEmpty(request.HTTPMethod), + IsReadOnly: request.IsReadOnly, + } + for key, value := range request.Parameters { + wire.Parameters[key] = encodeAwsApiValue(value, 0) + } + data, err := json.Marshal(wire) + if err != nil { + return "", fmt.Errorf("cfnvalidate: encoding AWS API request: %w", err) + } + return string(data), nil +} + +func nilIfEmpty(s string) *string { + if s == "" { + return nil + } + return &s +} + +// awsApiRequestWire is the JSON structure consumed by the Rust wire parser. +type awsApiRequestWire struct { + ServiceName string `json:"serviceName"` + OperationName string `json:"operationName"` + Parameters map[string]awsApiValue `json:"parameters"` + ServicePrefix *string `json:"servicePrefix,omitempty"` + HTTPMethod *string `json:"httpMethod,omitempty"` + IsReadOnly *bool `json:"isReadOnly,omitempty"` +} + +// awsApiValue is the tagged union wire format matching the core AwsApiValue +// serde representation (tag = "type", rename_all = "SCREAMING_SNAKE_CASE"). +// Items and Entries use pointer fields so that empty slices/maps serialize as +// their JSON zero ([] / {}) while remaining absent for unrelated variants. +type awsApiValue struct { + Type string `json:"type"` + Value any `json:"value,omitempty"` + Items *[]awsApiValue `json:"items,omitempty"` + Entries *map[string]awsApiValue `json:"entries,omitempty"` + TypeName string `json:"type_name,omitempty"` +} + +// maxEncodeDepth prevents stack overflow on cyclic or deeply nested structures. +const maxEncodeDepth = 64 + +// encodeAwsApiValue recursively converts a Go value into the tagged wire +// format. It is non-mutating: no pointer is followed through a write path. +// Unsupported types are represented as UNSUPPORTED rather than coerced. +// +// SDK-defined type aliases (e.g. types.InstanceType is a named string) are +// handled via reflect.Kind after concrete type checks, so any alias of a +// scalar kind is encoded correctly without enumerating every SDK type. +func encodeAwsApiValue(v any, depth int) awsApiValue { + if depth > maxEncodeDepth { + return awsApiValue{Type: "UNSUPPORTED", TypeName: "recursion depth exceeded"} + } + if v == nil { + return awsApiValue{Type: "NULL"} + } + + // Unwrap interface and pointer layers. Count indirections separately because + // a pointer-to-interface cycle can otherwise loop before recursive + // collection encoding reaches the depth guard. + rv := reflect.ValueOf(v) + indirections := 0 + for rv.Kind() == reflect.Ptr || rv.Kind() == reflect.Interface { + if depth+indirections > maxEncodeDepth { + return awsApiValue{Type: "UNSUPPORTED", TypeName: "recursion depth exceeded"} + } + if rv.IsNil() { + return awsApiValue{Type: "NULL"} + } + rv = rv.Elem() + indirections++ + } + v = rv.Interface() + + // Concrete type checks for stdlib types that carry semantics beyond their + // underlying kind (time.Time and json.Number). + switch val := v.(type) { + case time.Time: + return awsApiValue{Type: "STRING", Value: val.UTC().Format(time.RFC3339Nano)} + + case json.Number: + text := string(val) + if i, err := val.Int64(); err == nil { + return awsApiValue{Type: "INTEGER", Value: i} + } + if u, err := strconv.ParseUint(text, 10, 64); err == nil { + return awsApiValue{Type: "UNSIGNED_INTEGER", Value: u} + } + if !strings.ContainsAny(text, ".eE") && json.Valid([]byte(text)) { + return awsApiValue{Type: "UNSUPPORTED", TypeName: "integer outside 64-bit range"} + } + if f, err := val.Float64(); err == nil { + if math.IsInf(f, 0) || math.IsNaN(f) { + return awsApiValue{Type: "UNSUPPORTED", TypeName: "non-finite floating-point number"} + } + return awsApiValue{Type: "NUMBER", Value: f} + } + return awsApiValue{Type: "UNSUPPORTED", TypeName: "unparseable json.Number"} + } + + // Kind-based handling covers both built-in types and SDK-defined aliases + // (e.g. types.InstanceType is `type InstanceType string`). + switch rv.Kind() { + case reflect.Bool: + return awsApiValue{Type: "BOOLEAN", Value: rv.Bool()} + + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return awsApiValue{Type: "INTEGER", Value: rv.Int()} + + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return awsApiValue{Type: "UNSIGNED_INTEGER", Value: rv.Uint()} + + case reflect.Float32, reflect.Float64: + f := rv.Float() + if math.IsInf(f, 0) || math.IsNaN(f) { + return awsApiValue{Type: "UNSUPPORTED", TypeName: "non-finite floating-point number"} + } + return awsApiValue{Type: "NUMBER", Value: f} + + case reflect.String: + return awsApiValue{Type: "STRING", Value: rv.String()} + + case reflect.Slice, reflect.Array: + // []byte / [N]byte → BYTES, encoded as a JSON integer array so the + // Rust side receives Vec from serde (encoding/json marshals + // []byte as base64 which is incompatible with serde's Vec). + if rv.Type().Elem().Kind() == reflect.Uint8 { + ints := make([]int, rv.Len()) + for i := range ints { + ints[i] = int(rv.Index(i).Uint()) + } + return awsApiValue{Type: "BYTES", Value: ints} + } + items := make([]awsApiValue, rv.Len()) + for i := range items { + items[i] = encodeAwsApiValue(rv.Index(i).Interface(), depth+1) + } + return awsApiValue{Type: "ARRAY", Items: &items} + + case reflect.Map: + if rv.Type().Key().Kind() != reflect.String { + return awsApiValue{Type: "UNSUPPORTED", TypeName: "mapping with non-string keys"} + } + entries := make(map[string]awsApiValue, rv.Len()) + iter := rv.MapRange() + for iter.Next() { + entries[iter.Key().String()] = encodeAwsApiValue(iter.Value().Interface(), depth+1) + } + return awsApiValue{Type: "OBJECT", Entries: &entries} + + case reflect.Struct: + return awsApiValue{Type: "UNSUPPORTED", TypeName: rv.Type().String()} + + default: + return awsApiValue{Type: "UNSUPPORTED", TypeName: rv.Type().String()} + } +} + // SchemaValidator validates resources against the compiled CloudFormation // provider schemas. type SchemaValidator struct { diff --git a/src/bindings-go/go/cfnvalidate_test.go b/src/bindings-go/go/cfnvalidate_test.go new file mode 100644 index 00000000..5feb33f7 --- /dev/null +++ b/src/bindings-go/go/cfnvalidate_test.go @@ -0,0 +1,76 @@ +package cfnvalidate + +import ( + "encoding/json" + "strings" + "testing" + "time" +) + +func TestMarshalAWSAPIRequestFormatsTimeAsRFC3339UTC(t *testing.T) { + timestamp := time.Date(2025, time.January, 2, 3, 4, 5, 123456789, time.FixedZone("UTC+2", 2*60*60)) + + encoded := encodedAWSAPIParameter(t, timestamp) + + if got := encoded["type"]; got != "STRING" { + t.Fatalf("type = %v, want STRING", got) + } + if got := encoded["value"]; got != "2025-01-02T01:04:05.123456789Z" { + t.Errorf("value = %v, want RFC3339 UTC timestamp", got) + } +} + +func TestMarshalAWSAPIRequestPreservesUnsignedJSONNumber(t *testing.T) { + encoded := encodedAWSAPIParameter(t, json.Number("18446744073709551615")) + + if got := encoded["type"]; got != "UNSIGNED_INTEGER" { + t.Fatalf("type = %v, want UNSIGNED_INTEGER", got) + } + value, ok := encoded["value"].(json.Number) + if !ok { + t.Fatalf("value type = %T, want json.Number", encoded["value"]) + } + if got := value.String(); got != "18446744073709551615" { + t.Errorf("value = %s, want exact uint64 maximum", got) + } +} + +func TestMarshalAWSAPIRequestMarksOutOfRangeIntegerUnsupported(t *testing.T) { + encoded := encodedAWSAPIParameter(t, json.Number("18446744073709551616")) + + if got := encoded["type"]; got != "UNSUPPORTED" { + t.Fatalf("type = %v, want UNSUPPORTED", got) + } + if got := encoded["type_name"]; got != "integer outside 64-bit range" { + t.Errorf("type_name = %v, want integer outside 64-bit range", got) + } + if _, ok := encoded["value"]; ok { + t.Error("UNSUPPORTED value must not contain a numeric value") + } +} + +func encodedAWSAPIParameter(t *testing.T, value any) map[string]any { + t.Helper() + requestJSON, err := marshalAWSAPIRequest(AWSAPIRequest{ + ServiceName: "test", + OperationName: "TestOperation", + Parameters: map[string]any{"Value": value}, + }) + if err != nil { + t.Fatalf("marshalAWSAPIRequest failed: %v", err) + } + + decoder := json.NewDecoder(strings.NewReader(requestJSON)) + decoder.UseNumber() + var wire struct { + Parameters map[string]map[string]any `json:"parameters"` + } + if err := decoder.Decode(&wire); err != nil { + t.Fatalf("decoding request wire JSON failed: %v", err) + } + encoded, ok := wire.Parameters["Value"] + if !ok { + t.Fatal("encoded request is missing the Value parameter") + } + return encoded +} diff --git a/src/bindings-go/go/types.go b/src/bindings-go/go/types.go index 4bb3c67a..9037fc7d 100644 --- a/src/bindings-go/go/types.go +++ b/src/bindings-go/go/types.go @@ -299,3 +299,57 @@ type ValidateConfig struct { Strict *bool `json:"strict,omitempty"` DisableBuiltinRules *bool `json:"disableBuiltinRules,omitempty"` } + +// AWSAPIRequest holds an AWS API service call for offline CloudFormation +// validation. ServiceName and OperationName identify the API; Parameters carry +// the request values (maps, strings, numbers, booleans, byte slices, etc.). +type AWSAPIRequest struct { + ServiceName string `json:"serviceName"` + OperationName string `json:"operationName"` + Parameters map[string]any `json:"parameters"` + ServicePrefix string `json:"servicePrefix,omitempty"` + HTTPMethod string `json:"httpMethod,omitempty"` + IsReadOnly *bool `json:"isReadOnly,omitempty"` +} + +// AWSAPIOperationKind classifies an AWS API operation. +type AWSAPIOperationKind string + +const ( + AWSAPIOperationKindReadOnly AWSAPIOperationKind = "READ_ONLY" + AWSAPIOperationKindCloudFormationCreate AWSAPIOperationKind = "CLOUD_FORMATION_CREATE" + AWSAPIOperationKindCloudFormationUpdate AWSAPIOperationKind = "CLOUD_FORMATION_UPDATE" + AWSAPIOperationKindCloudFormationDelete AWSAPIOperationKind = "CLOUD_FORMATION_DELETE" + AWSAPIOperationKindDataPlaneMutation AWSAPIOperationKind = "DATA_PLANE_MUTATION" + AWSAPIOperationKindUnmappedMutation AWSAPIOperationKind = "UNMAPPED_MUTATION" +) + +// AWSAPIRequestValidationStatus indicates whether validation ran or was skipped. +type AWSAPIRequestValidationStatus string + +const ( + AWSAPIRequestValidationStatusValidated AWSAPIRequestValidationStatus = "VALIDATED" + AWSAPIRequestValidationStatusSkipped AWSAPIRequestValidationStatus = "SKIPPED" +) + +// AWSAPITemplateSource identifies the provenance of the template validated for +// an API request. +type AWSAPITemplateSource string + +const ( + AWSAPITemplateSourceTemplateBody AWSAPITemplateSource = "TEMPLATE_BODY" + AWSAPITemplateSourceCloudControlDesiredState AWSAPITemplateSource = "CLOUD_CONTROL_DESIRED_STATE" + AWSAPITemplateSourceSynthesizedCreate AWSAPITemplateSource = "SYNTHESIZED_CREATE" + AWSAPITemplateSourceSynthesizedUpdate AWSAPITemplateSource = "SYNTHESIZED_UPDATE" +) + +// AWSAPIRequestValidation is the canonical result of validating an AWS API +// request. Report is present only when Status is VALIDATED. +type AWSAPIRequestValidation struct { + OperationKind AWSAPIOperationKind `json:"operationKind"` + Status AWSAPIRequestValidationStatus `json:"status"` + TemplateSource *AWSAPITemplateSource `json:"templateSource,omitempty"` + ResourceTypes []string `json:"resourceTypes"` + Reason string `json:"reason"` + Report *StandardReport `json:"report,omitempty"` +} diff --git a/src/bindings-go/src/lib.rs b/src/bindings-go/src/lib.rs index 00cbbb87..3c48712b 100644 --- a/src/bindings-go/src/lib.rs +++ b/src/bindings-go/src/lib.rs @@ -177,6 +177,42 @@ fn to_json(value: &T) -> Result { serde_json::to_string(value).map_err(|e| ValidationError::new(format!("failed to serialize result: {e}"))) } +/// Wire struct for an AWS API request received from Go as JSON. +/// +/// Field names match the Go `AWSAPIRequest` struct's `json` tags exactly. +/// Unknown fields are rejected so a drifted field name surfaces as an error +/// instead of silently ignoring the caller's intent. +#[derive(Debug, serde::Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +struct AwsApiRequestWire { + service_name: String, + operation_name: String, + parameters: HashMap, + #[serde(default)] + service_prefix: Option, + #[serde(default)] + http_method: Option, + #[serde(default)] + is_read_only: Option, +} + +impl AwsApiRequestWire { + fn parse(json: &str) -> Result { + serde_json::from_str(json).map_err(|e| ValidationError::new(format!("invalid AWS API request JSON: {e}"))) + } + + fn into_context(self) -> validation_engine::AwsApiRequestContext { + validation_engine::AwsApiRequestContext { + service_name: self.service_name, + operation_name: self.operation_name, + parameters: self.parameters, + service_prefix: self.service_prefix, + http_method: self.http_method, + is_read_only: self.is_read_only, + } + } +} + #[derive(uniffi::Object)] pub struct GoSchemaValidator { inner: schema_validator::SchemaValidator, @@ -312,6 +348,29 @@ macro_rules! impl_go_engine { ) } + /// Validates an AWS API request and returns the canonical result as JSON. + pub fn validate_aws_api_request_json( + &self, + request_json: String, + options_json: String, + ) -> Result { + catch_panics( + || { + let request = AwsApiRequestWire::parse(&request_json)?.into_context(); + let config = ValidateOptions::parse(&options_json)?.to_core(DetailLevel::Standard); + let result = validation_engine::validate_aws_api_request( + &self.engine, + &self.schema_validator, + &request, + config, + ) + .map_err(ValidationError::new)?; + to_json(&result) + }, + panic_to_error, + ) + } + /// Returns the engine's rules as a JSON array of rule infos. pub fn list_rules_json(&self) -> Result { catch_panics(|| to_json(&self.engine.list_rules()), panic_to_error) @@ -616,4 +675,132 @@ mod tests { "error must identify the failing input: {error}" ); } + + #[test] + fn aws_api_request_parses_valid_minimal_request() { + let wire = AwsApiRequestWire::parse( + r#"{"serviceName":"s3","operationName":"CreateBucket","parameters":{"Bucket":{"type":"STRING","value":"test"}}}"#, + ) + .expect("valid minimal request must parse"); + + assert_eq!(wire.service_name, "s3"); + assert_eq!(wire.operation_name, "CreateBucket"); + assert!(wire.parameters.contains_key("Bucket")); + assert_eq!(wire.service_prefix, None); + assert_eq!(wire.http_method, None); + assert_eq!(wire.is_read_only, None); + } + + #[test] + fn aws_api_request_parses_nested_values_and_bytes() { + let wire = AwsApiRequestWire::parse( + r#"{ + "serviceName": "cloudformation", + "operationName": "CreateStack", + "parameters": { + "TemplateBody": {"type": "BYTES", "value": [123, 125]}, + "Tags": {"type": "ARRAY", "items": [ + {"type": "OBJECT", "entries": {"Key": {"type": "STRING", "value": "env"}}} + ]}, + "Count": {"type": "INTEGER", "value": 42} + }, + "servicePrefix": "cloudformation", + "httpMethod": "POST", + "isReadOnly": false + }"#, + ) + .expect("nested request must parse"); + + assert_eq!(wire.service_name, "cloudformation"); + assert_eq!(wire.service_prefix, Some("cloudformation".to_string())); + assert_eq!(wire.http_method, Some("POST".to_string())); + assert_eq!(wire.is_read_only, Some(false)); + + let context = wire.into_context(); + match context.parameters.get("TemplateBody") { + Some(validation_engine::AwsApiValue::Bytes { value }) => assert_eq!(value, &[123, 125]), + other => panic!("expected Bytes, got {other:?}"), + } + match context.parameters.get("Count") { + Some(validation_engine::AwsApiValue::Integer { value }) => assert_eq!(*value, 42), + other => panic!("expected Integer, got {other:?}"), + } + } + + #[test] + fn aws_api_request_rejects_malformed_json() { + let error = AwsApiRequestWire::parse("not json").expect_err("malformed JSON must fail"); + assert!( + error.to_string().contains("invalid AWS API request JSON"), + "error must identify the failing input: {error}" + ); + } + + #[test] + fn aws_api_request_rejects_unknown_fields() { + let error = AwsApiRequestWire::parse( + r#"{"serviceName":"s3","operationName":"CreateBucket","parameters":{},"unknownField":"x"}"#, + ) + .expect_err("unknown field must fail"); + assert!(error.to_string().contains("unknownField"), "error must name the offending key: {error}"); + } + + #[test] + fn aws_api_request_rejects_missing_required_fields() { + let error = + AwsApiRequestWire::parse(r#"{"serviceName":"s3"}"#).expect_err("missing required operationName must fail"); + assert!(error.to_string().contains("operationName"), "error must name the missing field: {error}"); + } + + #[test] + fn aws_api_value_unsupported_uses_type_name_field() { + let json = r#"{"type":"UNSUPPORTED","type_name":"non-finite floating-point number"}"#; + let value: validation_engine::AwsApiValue = + serde_json::from_str(json).expect("UNSUPPORTED with type_name must parse"); + match value { + validation_engine::AwsApiValue::Unsupported { type_name } => { + assert_eq!(type_name, "non-finite floating-point number"); + } + other => panic!("expected Unsupported, got {other:?}"), + } + } + + #[test] + fn aws_api_value_bytes_parses_integer_array() { + let json = r#"{"type":"BYTES","value":[72,101,108,108,111]}"#; + let value: validation_engine::AwsApiValue = + serde_json::from_str(json).expect("BYTES with integer array must parse"); + match value { + validation_engine::AwsApiValue::Bytes { value } => { + assert_eq!(value, vec![72, 101, 108, 108, 111]); + } + other => panic!("expected Bytes, got {other:?}"), + } + } + + #[test] + fn aws_api_value_empty_array_has_items_field() { + let json = r#"{"type":"ARRAY","items":[]}"#; + let value: validation_engine::AwsApiValue = + serde_json::from_str(json).expect("ARRAY with empty items must parse"); + match value { + validation_engine::AwsApiValue::Array { items } => { + assert!(items.is_empty()); + } + other => panic!("expected Array, got {other:?}"), + } + } + + #[test] + fn aws_api_value_empty_object_has_entries_field() { + let json = r#"{"type":"OBJECT","entries":{}}"#; + let value: validation_engine::AwsApiValue = + serde_json::from_str(json).expect("OBJECT with empty entries must parse"); + match value { + validation_engine::AwsApiValue::Object { entries } => { + assert!(entries.is_empty()); + } + other => panic!("expected Object, got {other:?}"), + } + } } diff --git a/src/bindings-go/tests/run.sh b/src/bindings-go/tests/run.sh index 5c356895..dab2274f 100755 --- a/src/bindings-go/tests/run.sh +++ b/src/bindings-go/tests/run.sh @@ -9,6 +9,9 @@ GO_MODULE="github.com/aws-cloudformation/cloudformation-validate/src/bindings-go [ -d "$GO_DIR/internal/bindings_go" ] && compgen -G "$GO_DIR/libs/*/libbindings_go.a" >/dev/null \ || { echo "Error: generated bindings or static library missing - run build.sh first" >&2; exit 1; } +echo "Running Go module unit tests..." +(cd "$GO_DIR" && go test ./...) + echo "Running smoke tests with coverage..." cd "$SCRIPT_DIR" go test -v -covermode=atomic -coverpkg="$GO_MODULE" -coverprofile="$SCRIPT_DIR/coverage.out" ./... diff --git a/src/bindings-jvm/README.md b/src/bindings-jvm/README.md index a3b1deae..0623d19f 100644 --- a/src/bindings-jvm/README.md +++ b/src/bindings-jvm/README.md @@ -13,8 +13,8 @@ All types live in the `software.amazon.cloudformation.validate` package. Available on [Maven Central](https://central.sonatype.com/artifact/software.amazon.cloudformation/cloudformation-validate) -as `software.amazon.cloudformation:cloudformation-validate`. Both snippets below resolve the latest published version; -substitute a specific version to pin one. +as `software.amazon.cloudformation:cloudformation-validate`. The library requires Java 8 or later. Both snippets below +resolve the latest published version; substitute a specific version to pin one. Gradle: @@ -76,6 +76,133 @@ interface Engine { `template` is a `java.io.File` - the engine reads the bytes and uses the file path for diagnostic source locations. +### AWS API request validation + +Use `validateAwsApiRequest` for AWS SDK-style request values rather than a complete template. The validator classifies +the operation, selects a CloudFormation resource type, models representable create/update state, and validates the +resulting template entirely offline: + +```kotlin +val result = RegoEngine().validateAwsApiRequest( + AwsApiRequest( + serviceName = "s3", + servicePrefix = "s3", + operationName = "CreateBucket", + httpMethod = "PUT", + parameters = mapOf( + "Bucket" to "example-bucket", + ), + ), +) + +result.report?.diagnostics?.forEach { diagnostic -> + println("${diagnostic.ruleId}: ${diagnostic.message}") +} ?: println("${result.status}: ${result.reason}") +``` + +`AwsApiRequest.parameters` accepts nested maps, iterables and arrays, scalars, byte arrays, and Java temporal values +without mutating the supplied map. `TemplateBody` bytes are validated exactly; `TemplateURL` is skipped because the +validator does not perform network requests. Every result reports `status`, `operationKind`, `templateSource`, +`resourceTypes`, and `reason`; skipped requests have a null `report`. +The same classes and methods are callable from Java with conventional generated getters. + +Operation-to-resource mapping uses a deterministic closed adapter catalog generated from each resource type's own +provider handler metadata and verified against botocore models and the compiled CloudFormation schemas: only +verified service+operation pairs produce inferred resource types and synthesized templates. Unregistered operations are classified as +`UNMAPPED_MUTATION` or `DATA_PLANE_MUTATION` with `SKIPPED` status and no inferred resource types. Cloud Control +`UpdateResource` and `DeleteResource` may echo a known `TypeName` supplied by the request, but never synthesize state. +The canonical `serviceName` is authoritative; `servicePrefix` cannot override it. Case normalization accepts CLI names +(for example, `s3`) and Java SDK `SERVICE_NAME` values (for example, `S3`) without fuzzy or punctuation aliases. +`TemplateBody` validation is restricted to CloudFormation operations that accept it, and +`TypeName`+`DesiredState` wrapping applies only to exact Cloud Control `CreateResource`. + +#### AWS SDK for Java 2.x integration + +An `ExecutionInterceptor` can validate the real `SdkRequest` in `beforeExecution`, before the SDK marshals or sends it. +Convert `SdkPojo` fields recursively so nested request models and `SdkBytes` retain their values: + +```java +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import software.amazon.awssdk.core.SdkBytes; +import software.amazon.awssdk.core.SdkField; +import software.amazon.awssdk.core.SdkPojo; +import software.amazon.awssdk.core.interceptor.Context; +import software.amazon.awssdk.core.interceptor.ExecutionAttributes; +import software.amazon.awssdk.core.interceptor.ExecutionInterceptor; +import software.amazon.awssdk.core.interceptor.SdkExecutionAttribute; +import software.amazon.cloudformation.validate.AwsApiRequest; +import software.amazon.cloudformation.validate.RegoEngine; +import software.amazon.cloudformation.validate.ValidateConfig; +import software.amazon.cloudformation.validate.engine.AwsApiRequestValidation; + +public final class CloudFormationValidationInterceptor implements ExecutionInterceptor { + private final RegoEngine engine = new RegoEngine(); + + @Override + public void beforeExecution(Context.BeforeExecution context, ExecutionAttributes attributes) { + AwsApiRequestValidation result = engine.validateAwsApiRequest( + new AwsApiRequest( + attributes.getAttribute(SdkExecutionAttribute.SERVICE_NAME), + attributes.getAttribute(SdkExecutionAttribute.OPERATION_NAME), + sdkFields(context.request()) + ), + new ValidateConfig() + ); + + if (result.getReport() != null) { + result.getReport().getDiagnostics().forEach(diagnostic -> + System.out.println(diagnostic.getRuleId() + ": " + diagnostic.getMessage()) + ); + } else { + System.out.println(result.getStatus() + ": " + result.getReason()); + } + } + + private static Map sdkFields(SdkPojo pojo) { + Map values = new LinkedHashMap<>(); + for (SdkField field : pojo.sdkFields()) { + Object value = field.getValueOrDefault(pojo); + if (value != null) { + values.put(field.memberName(), sdkValue(value)); + } + } + return values; + } + + private static Object sdkValue(Object value) { + if (value instanceof SdkBytes) { + return ((SdkBytes) value).asByteArray(); + } + if (value instanceof SdkPojo) { + return sdkFields((SdkPojo) value); + } + if (value instanceof Map) { + Map converted = new LinkedHashMap<>(); + for (Map.Entry entry : ((Map) value).entrySet()) { + converted.put(String.valueOf(entry.getKey()), sdkValue(entry.getValue())); + } + return converted; + } + if (value instanceof Iterable) { + List converted = new ArrayList<>(); + for (Object item : (Iterable) value) { + converted.add(sdkValue(item)); + } + return converted; + } + return value; + } +} +``` + +Register the interceptor through the SDK client's `overrideConfiguration`. The engine is safe to reuse; constructing it +for every request needlessly recompiles the bundled rules. The example reports findings, but an interceptor can instead +throw after applying application-specific policy to prevent the API call. The adapter adds no AWS SDK dependency to +`cloudformation-validate` itself. + ### `EngineConfig` Passed to the constructor. All fields default to empty lists. diff --git a/src/bindings-jvm/build.gradle.kts b/src/bindings-jvm/build.gradle.kts index 63a757ac..0eacabb8 100644 --- a/src/bindings-jvm/build.gradle.kts +++ b/src/bindings-jvm/build.gradle.kts @@ -1,3 +1,4 @@ +import org.jetbrains.kotlin.gradle.dsl.JvmTarget import java.util.Properties plugins { @@ -44,6 +45,14 @@ dependencies { kotlin { jvmToolchain(21) // keep in sync with configs.yml java-version + compilerOptions { + jvmTarget.set(JvmTarget.JVM_1_8) + } +} + +java { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 } // ── Source layout ─────────────────────────────────────────────────────────────── diff --git a/src/bindings-jvm/build.sh b/src/bindings-jvm/build.sh index b8b466e3..3639807b 100755 --- a/src/bindings-jvm/build.sh +++ b/src/bindings-jvm/build.sh @@ -122,6 +122,12 @@ if [ "$CLASS_COUNT" -eq 0 ] || [ "$KT_COUNT" -eq 0 ]; then echo "Error: $JAR_FILE is missing compiled output - $CLASS_COUNT .class and $KT_COUNT .kt entries (both must be non-zero)." >&2 exit 1 fi +PUBLIC_API_CLASS="software.amazon.cloudformation.validate.ApiKt" +CLASS_FILE_MAJOR=$(javap -classpath "$JAR_FILE" -verbose "$PUBLIC_API_CLASS" | awk '/major version:/ { print $3; exit }') +if [ "$CLASS_FILE_MAJOR" != "52" ]; then + echo "Error: $JAR_FILE must target Java 8 classfile version 52, found $CLASS_FILE_MAJOR." >&2 + exit 1 +fi for required_metadata in LICENSE NOTICE README.md THIRD-PARTY-LICENSES.txt; do if ! jar tf "$JAR_FILE" | grep -Fxq "META-INF/$required_metadata"; then echo "Error: $JAR_FILE is missing META-INF/$required_metadata" >&2 @@ -137,7 +143,7 @@ JAR_SIZE=$(du -sh "$JAR_FILE" | cut -f1) echo "" echo "Build complete: $GENERATED_DIR" echo " Kotlin sources: $KT_SIZE ($KT_COUNT .kt files bundled)" -echo " Compiled classes: $CLASS_COUNT .class entries bundled" +echo " Compiled classes: $CLASS_COUNT .class entries bundled (Java 8 bytecode)" echo " Native library: $LIB_SIZE ($LIB_NAME, bundled in jar)" echo " JAR: $JAR_SIZE ($(basename "$JAR_FILE"))" echo "" diff --git a/src/bindings-jvm/src/lib.rs b/src/bindings-jvm/src/lib.rs index 261b6c5d..84c24622 100644 --- a/src/bindings-jvm/src/lib.rs +++ b/src/bindings-jvm/src/lib.rs @@ -22,7 +22,10 @@ pub use template_model::model::{ }; pub use template_model::resolver::{MapEntry, ParameterInfo, RefKind, ResolvedValue}; pub use template_model::{JsonValue, PseudoParameterOverrides, SourceSpan}; -pub use validation_engine::{EngineConfig, EngineType, ExternalRuleSource}; +pub use validation_engine::{ + AwsApiOperationKind, AwsApiRequestContext, AwsApiRequestValidation, AwsApiRequestValidationStatus, + AwsApiTemplateSource, AwsApiValue, EngineConfig, EngineType, ExternalRuleSource, +}; pub use schema_validator::SchemaValidatorConfig; @@ -197,6 +200,27 @@ macro_rules! impl_jvm_engine { ) } + pub fn validate_aws_api_request( + &self, + request: AwsApiRequestContext, + config: ValidateConfig, + ) -> Result { + validation_engine::catch_panics( + || { + let core_config = config.to_core(DetailLevel::Standard); + let validation = validation_engine::validate_aws_api_request( + &self.engine, + &self.schema_validator, + &request, + core_config, + ) + .map_err(|e| ValidationError::Engine { msg: e.to_string() })?; + Ok(validation) + }, + panic_to_error, + ) + } + pub fn list_rules(&self) -> Result, ValidationError> { validation_engine::catch_panics(|| Ok(self.engine.list_rules()), panic_to_error) } diff --git a/src/bindings-jvm/src/main/kotlin/software/amazon/cloudformation/validate/Api.kt b/src/bindings-jvm/src/main/kotlin/software/amazon/cloudformation/validate/Api.kt index 0947bf53..0ba69f66 100644 --- a/src/bindings-jvm/src/main/kotlin/software/amazon/cloudformation/validate/Api.kt +++ b/src/bindings-jvm/src/main/kotlin/software/amazon/cloudformation/validate/Api.kt @@ -4,6 +4,9 @@ import software.amazon.cloudformation.validate.datasource.AdditionalSchemaSource import software.amazon.cloudformation.validate.diagnostics.DetailedReport import software.amazon.cloudformation.validate.diagnostics.StandardDiagnostic import software.amazon.cloudformation.validate.diagnostics.StandardReport +import software.amazon.cloudformation.validate.engine.AwsApiRequestContext as NativeAwsApiRequest +import software.amazon.cloudformation.validate.engine.AwsApiRequestValidation +import software.amazon.cloudformation.validate.engine.AwsApiValue as NativeAwsApiValue import software.amazon.cloudformation.validate.engine.EngineConfig import software.amazon.cloudformation.validate.engine.ExternalRuleSource import software.amazon.cloudformation.validate.rules.RuleInfo @@ -13,10 +16,83 @@ import java.io.File interface Engine { fun validateStandard(template: File, config: ValidateConfig = ValidateConfig()): StandardReport fun validateDetailed(template: File, config: ValidateConfig = ValidateConfig()): DetailedReport + fun validateAwsApiRequest( + request: AwsApiRequest, + config: ValidateConfig = ValidateConfig(), + ): AwsApiRequestValidation fun listRules(): List fun engineName(): String } +/** + * Service, operation, and request values for CloudFormation validation. + * + * [parameters] accepts nested maps/lists, strings, numbers, booleans, nulls, + * byte arrays, and Java time values. Unsupported values are marked explicitly + * and conservatively omitted during request-to-template synthesis. + */ +class AwsApiRequest @JvmOverloads constructor( + val serviceName: String, + val operationName: String, + parameters: Map, + val servicePrefix: String? = null, + val httpMethod: String? = null, + val isReadOnly: Boolean? = null, +) { + val parameters: Map = LinkedHashMap(parameters) + + internal fun toNative(): NativeAwsApiRequest = + NativeAwsApiRequest( + serviceName = serviceName, + operationName = operationName, + parameters = parameters.mapValues { (_, value) -> value.toNativeAwsApiValue() }, + servicePrefix = servicePrefix, + httpMethod = httpMethod, + isReadOnly = isReadOnly, + ) +} + +private fun Any?.toNativeAwsApiValue(): NativeAwsApiValue = + when (this) { + null -> NativeAwsApiValue.Null + is Boolean -> NativeAwsApiValue.Boolean(value = this) + is Byte -> NativeAwsApiValue.Integer(value = toLong()) + is Short -> NativeAwsApiValue.Integer(value = toLong()) + is Int -> NativeAwsApiValue.Integer(value = toLong()) + is Long -> NativeAwsApiValue.Integer(value = this) + is UByte -> NativeAwsApiValue.UnsignedInteger(value = toULong()) + is UShort -> NativeAwsApiValue.UnsignedInteger(value = toULong()) + is UInt -> NativeAwsApiValue.UnsignedInteger(value = toULong()) + is ULong -> NativeAwsApiValue.UnsignedInteger(value = this) + is Float -> + if (isFinite()) { + NativeAwsApiValue.Number(value = toDouble()) + } else { + NativeAwsApiValue.Unsupported(typeName = "non-finite floating-point number") + } + is Double -> + if (isFinite()) { + NativeAwsApiValue.Number(value = this) + } else { + NativeAwsApiValue.Unsupported(typeName = "non-finite floating-point number") + } + is String -> NativeAwsApiValue.String(value = this) + is ByteArray -> NativeAwsApiValue.Bytes(value = this) + is java.time.temporal.TemporalAccessor -> NativeAwsApiValue.String(value = toString()) + is Map<*, *> -> { + if (keys.any { it !is String }) { + NativeAwsApiValue.Unsupported(typeName = "mapping with non-string keys") + } else { + NativeAwsApiValue.Object( + entries = entries.associate { (key, value) -> key as String to value.toNativeAwsApiValue() }, + ) + } + } + is Iterable<*> -> NativeAwsApiValue.Array(items = map { it.toNativeAwsApiValue() }) + is Array<*> -> NativeAwsApiValue.Array(items = map { it.toNativeAwsApiValue() }) + else -> NativeAwsApiValue.Unsupported(typeName = javaClass.name) + } + /** * Reads a resource provider schema file into an [AdditionalSchemaSource] for * [SchemaValidatorConfig.additionalSchemas]. [typeName] may be omitted when the @@ -70,6 +146,11 @@ class RegoEngine( override fun validateDetailed(template: File, config: ValidateConfig): DetailedReport = inner.validateDetailed(template.readBytes(), config, template.path) + override fun validateAwsApiRequest( + request: AwsApiRequest, + config: ValidateConfig, + ): AwsApiRequestValidation = inner.validateAwsApiRequest(request.toNative(), config) + override fun listRules(): List = inner.listRules() override fun engineName(): String = inner.engineName() } @@ -85,6 +166,11 @@ class CelEngine( override fun validateDetailed(template: File, config: ValidateConfig): DetailedReport = inner.validateDetailed(template.readBytes(), config, template.path) + override fun validateAwsApiRequest( + request: AwsApiRequest, + config: ValidateConfig, + ): AwsApiRequestValidation = inner.validateAwsApiRequest(request.toNative(), config) + override fun listRules(): List = inner.listRules() override fun engineName(): String = inner.engineName() } diff --git a/src/bindings-jvm/uniffi.toml b/src/bindings-jvm/uniffi.toml index 5d7d9ef6..b8964653 100644 --- a/src/bindings-jvm/uniffi.toml +++ b/src/bindings-jvm/uniffi.toml @@ -1,6 +1,7 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate" generate_immutable_records = true +disable_java_cleaner = true [bindings.kotlin.external_packages] diagnostics = "software.amazon.cloudformation.validate.diagnostics" diff --git a/src/bindings-python/README.md b/src/bindings-python/README.md index 756b05a3..a565c5a9 100644 --- a/src/bindings-python/README.md +++ b/src/bindings-python/README.md @@ -17,7 +17,7 @@ Available on [PyPI](https://pypi.org/project/cloudformation-validate/) as `cloud pip install cloudformation-validate ``` -Requires Python 3.12+ and has no runtime dependencies. PyPI publishes a separate wheel for every supported native +Requires Python 3.9+ and has no runtime dependencies. PyPI publishes a separate wheel for every supported native target. Each wheel carries exactly one native library and an accurate platform tag, so pip downloads only the artifact compatible with the installer host. @@ -57,6 +57,91 @@ the same template and config. `template` is a file path (`str` / `os.PathLike`) or raw `bytes`; `config` is an optional `ValidateConfig`. +### AWS API request validation + +Use `validate_aws_api_request` when the input is an AWS SDK-style request rather than a complete template. The +validator classifies the operation, selects a CloudFormation resource type, models representable create/update state, +and validates the resulting template entirely offline: + +```python +from cloudformation_validate import AwsApiRequest, RegoEngine + +engine = RegoEngine() +result = engine.validate_aws_api_request( + AwsApiRequest( + service_name="s3", + service_prefix="s3", + operation_name="CreateBucket", + http_method="PUT", + parameters={"Bucket": "example-bucket"}, + ) +) + +if result.report is not None: + for diagnostic in result.report.diagnostics: + print(diagnostic.rule_id, diagnostic.message) +else: + print(result.status.name, result.reason) +``` + +`AwsApiRequest.parameters` accepts nested mappings and sequences, scalars, `bytes`, and `datetime.datetime` values +without mutating the supplied mapping. `TemplateBody` bytes are validated exactly; `TemplateURL` is skipped because the +validator does not perform network requests. The result always reports `status`, `operation_kind`, `template_source`, +`resource_types`, and `reason`; skipped requests have `report is None`. The `template` field carries the exact bytes +validated — the caller's original `TemplateBody` without reserializing, or the synthesized JSON for adapter-mapped +requests — so consumers can display the modeled template that produced the diagnostics. Skipped requests have +`template is None`. + +Operation-to-resource mapping uses a deterministic closed adapter catalog generated from each resource type's own +provider handler metadata and verified against botocore models and the compiled CloudFormation schemas: only +verified service+operation pairs produce inferred resource types and synthesized templates. Unregistered operations are classified as +`UNMAPPED_MUTATION` or `DATA_PLANE_MUTATION` with `SKIPPED` status and no inferred resource types. Cloud Control +`UpdateResource` and `DeleteResource` may echo a known `TypeName` supplied by the request, but never synthesize state. +The canonical `service_name` is authoritative; `service_prefix` cannot override it. Case normalization accepts CLI +names (for example, `s3`) and Java SDK casing (for example, `S3`) without fuzzy or punctuation aliases. +`TemplateBody` validation is restricted to CloudFormation operations that accept it, and +`TypeName`+`DesiredState` wrapping applies only to exact Cloud Control `CreateResource`. + +#### AWS CLI integration + +AWS CLI emits `provide-client-params..` before serializing or sending each request. Register a +handler on the CLI's botocore session to validate the exact parameter dictionary without making another network call: + +```python +from cloudformation_validate import AwsApiRequest, RegoEngine + +engine = RegoEngine() # construct once and reuse + + +def validate_create_stack(params, model, **_kwargs): + service = model.service_model + result = engine.validate_aws_api_request( + AwsApiRequest( + service_name=service.service_name, + service_prefix=service.signing_name, + operation_name=model.name, + http_method=model.http.get("method"), + parameters=params, + ) + ) + if result.report is not None: + for diagnostic in result.report.diagnostics: + print(diagnostic.rule_id, diagnostic.message) + else: + print(result.status.name, result.reason) + + +# `session` is the botocore session owned by the AWS CLI driver or plugin. +session.register( + "provide-client-params.cloudformation.CreateStack", + validate_create_stack, +) +``` + +The callback receives the real botocore `OperationModel`, so it does not need a duplicate service model. For +`CreateStack` and `UpdateStack`, the request's `TemplateBody` string or bytes are validated exactly. A handler that +must prevent the API call can raise after applying its own policy to the returned diagnostics. + ### EngineConfig Passed to the constructor. All fields default to empty lists. diff --git a/src/bindings-python/build.sh b/src/bindings-python/build.sh index 7e512398..1d25b878 100755 --- a/src/bindings-python/build.sh +++ b/src/bindings-python/build.sh @@ -10,6 +10,7 @@ RELEASE_DIR="$WORKSPACE/target/release" PYTHON_SRC="$SCRIPT_DIR/python/cloudformation_validate" PACKAGE_DIR="$GENERATED_DIR/cloudformation_validate" WHEEL_DIR="$GENERATED_DIR/dist" +PYTHON="${PYTHON:-python3}" ARCH="$(bash "$REPOSITORY_ROOT/scripts/build-support/rust-host-architecture.sh")" case "$ARCH" in @@ -65,12 +66,12 @@ Build directories: EOF # ── Prerequisites ───────────────────────────────────────────────────────────── -command -v python3 &>/dev/null || { echo "Error: python3 not found on PATH" >&2; exit 1; } +command -v "$PYTHON" &>/dev/null || { echo "Error: $PYTHON not found on PATH" >&2; exit 1; } command -v unzip &>/dev/null || { echo "Error: unzip not found on PATH" >&2; exit 1; } -python3 -c 'import sys; sys.exit(0 if sys.version_info >= (3, 12) else 1)' \ - || { echo "Error: Python 3.12+ required, found $(python3 --version)" >&2; exit 1; } -python3 -m pip --version &>/dev/null \ - || { echo "Error: pip not available (python3 -m pip failed)" >&2; exit 1; } +"$PYTHON" -c 'import sys; sys.exit(0 if sys.version_info >= (3, 9) else 1)' \ + || { echo "Error: Python 3.9+ required, found $("$PYTHON" --version)" >&2; exit 1; } +"$PYTHON" -m pip --version &>/dev/null \ + || { echo "Error: pip not available ($PYTHON -m pip failed)" >&2; exit 1; } # ── Clean ───────────────────────────────────────────────────────────────────── echo "Cleaning previous build..." @@ -103,7 +104,7 @@ echo "Generating Python bindings..." # generated code is deterministic regardless of build host; these bindings # are order-independent, so this is safe. echo "Patching native loader and normalizing generated modules..." -python3 - "$PACKAGE_DIR" <<'EOF' +"$PYTHON" - "$PACKAGE_DIR" <<'EOF' import pathlib import re import sys @@ -141,7 +142,8 @@ for module in modules: text = module.read_text(encoding="utf-8") if OLD not in text: sys.exit(f"error: expected loader line not found in {module.name} - did the uniffi template change?") - module.write_text(sort_relative_imports(text.replace(OLD, NEW)), encoding="utf-8", newline="\n") + with module.open("w", encoding="utf-8", newline="\n") as output: + output.write(sort_relative_imports(text.replace(OLD, NEW))) print(f" patched {len(modules)} modules") EOF @@ -169,7 +171,7 @@ cp "$SCRIPT_DIR/README.md" "$PACKAGE_DIR/README.md" # ── Build wheel ─────────────────────────────────────────────────────────────── echo "Building wheel..." cd "$GENERATED_DIR" -python3 -m pip wheel --no-deps --wheel-dir "$WHEEL_DIR" . --quiet +"$PYTHON" -m pip wheel --no-deps --wheel-dir "$WHEEL_DIR" . --quiet # ── Retag wheel with the host platform ─────────────────────────────────────── case "$OS" in @@ -194,7 +196,7 @@ case "$OS" in ;; esac echo "Retagging wheel as py3-none-${PLATFORM_TAG}..." -python3 - "$WHEEL_DIR" "$PLATFORM_TAG" <<'EOF' +"$PYTHON" - "$WHEEL_DIR" "$PLATFORM_TAG" <<'EOF' import base64 import csv import hashlib diff --git a/src/bindings-python/pyproject.toml b/src/bindings-python/pyproject.toml index 4f7cf2e3..bd727ed9 100644 --- a/src/bindings-python/pyproject.toml +++ b/src/bindings-python/pyproject.toml @@ -9,7 +9,7 @@ description = "Fast, offline, embeddable validation for AWS CloudFormation templ readme = "README.md" license = "Apache-2.0" license-files = ["LICENSE", "NOTICE", "THIRD-PARTY-LICENSES.txt"] -requires-python = ">=3.12" +requires-python = ">=3.9" authors = [{ name = "Amazon Web Services" }] keywords = [ "aws", @@ -30,6 +30,9 @@ classifiers = [ "Operating System :: Microsoft :: Windows", "Operating System :: POSIX :: Linux", "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Rust", "Topic :: Software Development :: Libraries :: Python Modules", diff --git a/src/bindings-python/python/cloudformation_validate/__init__.py b/src/bindings-python/python/cloudformation_validate/__init__.py index f6fc1d5b..e7cc29a4 100644 --- a/src/bindings-python/python/cloudformation_validate/__init__.py +++ b/src/bindings-python/python/cloudformation_validate/__init__.py @@ -15,8 +15,11 @@ from __future__ import annotations +import datetime +import math import os import typing +from collections.abc import Mapping from .bindings_python import ( PyCelEngine as _PyCelEngine, @@ -90,10 +93,25 @@ ) from .data_source import AdditionalSchemaSource from .schema_validator import SchemaValidatorConfig -from .validation_engine import EngineConfig, EngineType, ExternalRuleSource +from .validation_engine import ( + AwsApiOperationKind, + AwsApiRequestContext as _NativeAwsApiRequest, + AwsApiRequestValidation, + AwsApiRequestValidationStatus, + AwsApiTemplateSource, + AwsApiValue as _NativeAwsApiValue, + EngineConfig, + EngineType, + ExternalRuleSource, +) __all__ = [ "AdditionalSchemaSource", + "AwsApiOperationKind", + "AwsApiRequest", + "AwsApiRequestValidation", + "AwsApiRequestValidationStatus", + "AwsApiTemplateSource", "CelEngine", "ConditionalNull", "ConditionalNullEntry", @@ -203,6 +221,83 @@ def file_to_external_rule_source(path: typing.Union[str, os.PathLike]) -> Extern return ExternalRuleSource(name=str(resolved), content=f.read()) +class AwsApiRequest: + """Service, operation, and request values for CloudFormation validation. + + ``parameters`` accepts the same Python values used by botocore request + dictionaries, including nested mappings/sequences, ``bytes``, and + ``datetime.datetime``. Values that cannot be represented are carried as an + explicit unsupported marker. Synthesis enforces all-or-nothing semantics: + if any supplied non-control resource-state field lacks a lossless mapping, + the entire synthesis/validation is skipped with a reason naming the + offending parameter — no parameter is ever silently omitted. + """ + + def __init__( + self, + service_name: str, + operation_name: str, + parameters: Mapping[str, object], + *, + service_prefix: typing.Optional[str] = None, + http_method: typing.Optional[str] = None, + is_read_only: typing.Optional[bool] = None, + ): + if not isinstance(parameters, Mapping): + raise TypeError("parameters must be a mapping") + if not all(isinstance(name, str) for name in parameters): + raise TypeError("request parameter names must be strings") + self.service_name = service_name + self.operation_name = operation_name + self.parameters = dict(parameters) + self.service_prefix = service_prefix + self.http_method = http_method + self.is_read_only = is_read_only + + def _to_native(self) -> _NativeAwsApiRequest: + return _NativeAwsApiRequest( + service_name=self.service_name, + operation_name=self.operation_name, + parameters={name: _to_native_aws_api_value(value) for name, value in self.parameters.items()}, + service_prefix=self.service_prefix, + http_method=self.http_method, + is_read_only=self.is_read_only, + ) + + +def _to_native_aws_api_value(value: object) -> _NativeAwsApiValue: + if value is None: + return _NativeAwsApiValue.NULL() + if isinstance(value, bool): + return _NativeAwsApiValue.BOOLEAN(value=value) + if isinstance(value, int): + if -(2**63) <= value < 2**63: + return _NativeAwsApiValue.INTEGER(value=value) + if 0 <= value < 2**64: + return _NativeAwsApiValue.UNSIGNED_INTEGER(value=value) + return _NativeAwsApiValue.UNSUPPORTED(type_name="integer outside the 64-bit request range") + if isinstance(value, float): + if math.isfinite(value): + return _NativeAwsApiValue.NUMBER(value=value) + return _NativeAwsApiValue.UNSUPPORTED(type_name="non-finite floating-point number") + if isinstance(value, str): + return _NativeAwsApiValue.STRING(value=value) + if isinstance(value, (bytes, bytearray, memoryview)): + return _NativeAwsApiValue.BYTES(value=bytes(value)) + if isinstance(value, datetime.datetime): + return _NativeAwsApiValue.STRING(value=value.isoformat()) + if isinstance(value, Mapping): + if not all(isinstance(name, str) for name in value): + return _NativeAwsApiValue.UNSUPPORTED(type_name="mapping with non-string keys") + return _NativeAwsApiValue.OBJECT( + entries={name: _to_native_aws_api_value(item) for name, item in value.items()} + ) + if isinstance(value, (list, tuple)): + return _NativeAwsApiValue.ARRAY(items=[_to_native_aws_api_value(item) for item in value]) + value_type = type(value) + return _NativeAwsApiValue.UNSUPPORTED(type_name=f"{value_type.__module__}.{value_type.__qualname__}") + + class Engine: """Validates CloudFormation templates against the built-in rule set. @@ -232,6 +327,21 @@ def validate_detailed(self, template: Template, config: typing.Optional[Validate content, path = _template_bytes(template) return self._inner.validate_detailed(content, config if config is not None else ValidateConfig(), path) + def validate_aws_api_request( + self, request: AwsApiRequest, config: typing.Optional[ValidateConfig] = None + ) -> AwsApiRequestValidation: + """Classifies, models, and validates an AWS API request. + + A skipped request has ``report is None`` and an explicit status and reason. + The ``template`` field carries the exact bytes validated (the caller's + original ``TemplateBody`` or the synthesized JSON), or ``None`` when skipped. + """ + if not isinstance(request, AwsApiRequest): + raise TypeError("request must be an AwsApiRequest") + return self._inner.validate_aws_api_request( + request._to_native(), config if config is not None else ValidateConfig() + ) + def list_rules(self) -> typing.List[RuleInfo]: """Lists every rule this engine evaluates, sorted by rule ID.""" return self._inner.list_rules() diff --git a/src/bindings-python/src/lib.rs b/src/bindings-python/src/lib.rs index 84d2727b..bc8a9b51 100644 --- a/src/bindings-python/src/lib.rs +++ b/src/bindings-python/src/lib.rs @@ -22,7 +22,10 @@ pub use template_model::model::{ }; pub use template_model::resolver::{MapEntry, ParameterInfo, RefKind, ResolvedValue}; pub use template_model::{JsonValue, PseudoParameterOverrides, SourceSpan}; -pub use validation_engine::{EngineConfig, EngineType, ExternalRuleSource}; +pub use validation_engine::{ + AwsApiOperationKind, AwsApiRequestContext, AwsApiRequestValidation, AwsApiRequestValidationStatus, + AwsApiTemplateSource, AwsApiValue, EngineConfig, EngineType, ExternalRuleSource, +}; pub use schema_validator::SchemaValidatorConfig; @@ -197,6 +200,27 @@ macro_rules! impl_py_engine { ) } + pub fn validate_aws_api_request( + &self, + request: AwsApiRequestContext, + config: ValidateConfig, + ) -> Result { + validation_engine::catch_panics( + || { + let core_config = config.to_core(DetailLevel::Standard); + let validation = validation_engine::validate_aws_api_request( + &self.engine, + &self.schema_validator, + &request, + core_config, + ) + .map_err(|e| ValidationError::Engine { msg: e.to_string() })?; + Ok(validation) + }, + panic_to_error, + ) + } + pub fn list_rules(&self) -> Result, ValidationError> { validation_engine::catch_panics(|| Ok(self.engine.list_rules()), panic_to_error) } diff --git a/src/bindings-python/tests/run.sh b/src/bindings-python/tests/run.sh index 2bd5a503..d3b8c62d 100755 --- a/src/bindings-python/tests/run.sh +++ b/src/bindings-python/tests/run.sh @@ -5,6 +5,12 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" BINDINGS_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" WHEEL_DIR="$BINDINGS_DIR/generated/dist" VENV_DIR="$SCRIPT_DIR/.venv" +PYTHON="${PYTHON:-python3}" + +if ! command -v "$PYTHON" &>/dev/null; then + echo "Error: $PYTHON not found on PATH" >&2 + exit 1 +fi if ! compgen -G "$WHEEL_DIR/cloudformation_validate-*.whl" >/dev/null; then echo "Error: no wheel in $WHEEL_DIR - run build.sh first" >&2 @@ -15,7 +21,7 @@ fi # consumers install, not the loose build tree. echo "Installing the compatible wheel from $WHEEL_DIR into test venv..." rm -rf "$VENV_DIR" -python3 -m venv "$VENV_DIR" +"$PYTHON" -m venv "$VENV_DIR" if [ -x "$VENV_DIR/bin/python" ]; then VENV_PYTHON="$VENV_DIR/bin/python" else diff --git a/src/data-source/README.md b/src/data-source/README.md index 4e32b9e1..6284ed0a 100644 --- a/src/data-source/README.md +++ b/src/data-source/README.md @@ -8,19 +8,26 @@ compile time. Everything compiles into the binary - no runtime fetching. ## Commands ```bash -# Generate from existing upstream data +# Generate schema and rule artifacts from existing upstream data cargo run -p data-source --features maintenance --example generate -# Refresh all upstream sources, then generate every output (cfn-lint root is required) -cargo run -p data-source --features maintenance --example sync -- --cfn-lint-root +# Refresh every upstream source and generate every output, including the AWS API operation catalog +cargo run -p data-source --features maintenance --example sync -- \ + --cfn-lint-root \ + --aws-cli-root ``` The `generate` and `sync` examples require the `maintenance` feature, which enables dependencies used only by the data maintenance pipeline. `sync` is the complete workflow: it refreshes every upstream source, records source -versions, and generates all outputs. `generate` reruns code generation from the existing upstream data without network -access. +versions, generates the schema and rule outputs, then generates and verifies the AWS API operation catalog. Pass the +AWS CLI checkout root through `--aws-cli-root`; sync derives its bundled botocore package path, and the catalog +generator runs its unit tests before generating the catalog. -`--cfn-lint-root` is required by `sync`, which fails before starting work when it is absent. +`generate` reruns schema and rule generation from existing upstream data without network access. It does not rebuild +the AWS API operation catalog because that step requires botocore service models and is owned by the complete `sync` +workflow. + +`--cfn-lint-root` and `--aws-cli-root` are required by `sync`, which fails before starting work when either is absent. A successful sync records both strict, source-qualified values together only after all source processing succeeds. ## Directory Structure diff --git a/src/data-source/build.rs b/src/data-source/build.rs index 4aee85ba..5ba8ccef 100644 --- a/src/data-source/build.rs +++ b/src/data-source/build.rs @@ -25,6 +25,7 @@ const GENERATED_JSON: &[(&str, &str)] = &[ ("data/getatt_attributes.json", "GETATT_ATTRIBUTES"), ("data/known_resource_types.json", "KNOWN_RESOURCE_TYPES"), ("data/stateful_resource_types.json", "STATEFUL_RESOURCE_TYPES"), + ("data/aws_api_operation_catalog.json", "AWS_API_OPERATION_CATALOG"), ("data/retention_period_requirements.json", "RETENTION_PERIOD_REQUIREMENTS"), ("data/codepipeline_action_artifact_counts.json", "CODEPIPELINE_ACTION_ARTIFACT_COUNTS"), ("data/aws_rds_dbinstance_dbinstanceclass_enum.json", "AWS_RDS_DBINSTANCE_DBINSTANCECLASS_ENUM"), diff --git a/src/data-source/generated/data/aws_api_operation_catalog.json b/src/data-source/generated/data/aws_api_operation_catalog.json new file mode 100644 index 00000000..22a69e0d --- /dev/null +++ b/src/data-source/generated/data/aws_api_operation_catalog.json @@ -0,0 +1,47929 @@ +{ + "adapters": [ + { + "cfn_type": "AWS::ACMPCA::Certificate", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "CertificateAuthorityArn", + "target": "CertificateAuthorityArn" + }, + { + "source": "SigningAlgorithm", + "target": "SigningAlgorithm" + }, + { + "source": "TemplateArn", + "target": "TemplateArn" + } + ], + "operation": "IssueCertificate", + "phase": "create", + "service": "acm-pca" + }, + { + "cfn_type": "AWS::ACMPCA::CertificateAuthority", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "KeyStorageSecurityStandard", + "target": "KeyStorageSecurityStandard" + }, + { + "source": "UsageMode", + "target": "UsageMode" + } + ], + "operation": "CreateCertificateAuthority", + "phase": "create", + "service": "acm-pca" + }, + { + "cfn_type": "AWS::ACMPCA::CertificateAuthority", + "mappings": [], + "operation": "DeleteCertificateAuthority", + "phase": "delete", + "service": "acm-pca" + }, + { + "cfn_type": "AWS::ACMPCA::Permission", + "mappings": [ + { + "source": "Actions", + "target": "Actions" + }, + { + "source": "CertificateAuthorityArn", + "target": "CertificateAuthorityArn" + }, + { + "source": "Principal", + "target": "Principal" + }, + { + "source": "SourceAccount", + "target": "SourceAccount" + } + ], + "operation": "CreatePermission", + "phase": "create", + "service": "acm-pca" + }, + { + "cfn_type": "AWS::ACMPCA::Permission", + "mappings": [ + { + "source": "CertificateAuthorityArn", + "target": "CertificateAuthorityArn" + }, + { + "source": "Principal", + "target": "Principal" + }, + { + "source": "SourceAccount", + "target": "SourceAccount" + } + ], + "operation": "DeletePermission", + "phase": "delete", + "service": "acm-pca" + }, + { + "cfn_type": "AWS::AIOps::InvestigationGroup", + "mappings": [ + { + "source": "isCloudTrailEventHistoryEnabled", + "target": "IsCloudTrailEventHistoryEnabled" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "retentionInDays", + "target": "RetentionInDays" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tagKeyBoundaries", + "target": "TagKeyBoundaries" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateInvestigationGroup", + "phase": "create", + "service": "aiops" + }, + { + "cfn_type": "AWS::AIOps::InvestigationGroup", + "mappings": [], + "operation": "DeleteInvestigationGroup", + "phase": "delete", + "service": "aiops" + }, + { + "cfn_type": "AWS::APS::AnomalyDetector", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "alias", + "target": "Alias" + }, + { + "source": "evaluationIntervalInSeconds", + "target": "EvaluationIntervalInSeconds" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAnomalyDetector", + "phase": "create", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::AnomalyDetector", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteAnomalyDetector", + "phase": "delete", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::ResourcePolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "policyDocument", + "target": "PolicyDocument" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::ResourcePolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::RuleGroupsNamespace", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateRuleGroupsNamespace", + "phase": "create", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::RuleGroupsNamespace", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteRuleGroupsNamespace", + "phase": "delete", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::Scraper", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "alias", + "target": "Alias" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateScraper", + "phase": "create", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::Scraper", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteScraper", + "phase": "delete", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::Workspace", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "alias", + "target": "Alias" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateWorkspace", + "phase": "create", + "service": "amp" + }, + { + "cfn_type": "AWS::APS::Workspace", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteWorkspace", + "phase": "delete", + "service": "amp" + }, + { + "cfn_type": "AWS::ARCRegionSwitch::Plan", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "executionRole", + "target": "ExecutionRole" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "primaryRegion", + "target": "PrimaryRegion" + }, + { + "source": "recoveryApproach", + "target": "RecoveryApproach" + }, + { + "source": "recoveryTimeObjectiveMinutes", + "target": "RecoveryTimeObjectiveMinutes" + }, + { + "source": "regions", + "target": "Regions" + } + ], + "operation": "CreatePlan", + "phase": "create", + "service": "arc-region-switch" + }, + { + "cfn_type": "AWS::ARCRegionSwitch::Plan", + "mappings": [], + "operation": "DeletePlan", + "phase": "delete", + "service": "arc-region-switch" + }, + { + "cfn_type": "AWS::AccessAnalyzer::Analyzer", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "analyzerName", + "target": "AnalyzerName" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateAnalyzer", + "phase": "create", + "service": "accessanalyzer" + }, + { + "cfn_type": "AWS::AccessAnalyzer::Analyzer", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "analyzerName", + "target": "AnalyzerName" + } + ], + "operation": "DeleteAnalyzer", + "phase": "delete", + "service": "accessanalyzer" + }, + { + "cfn_type": "AWS::AccessAnalyzer::ArchiveRule", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "analyzerName", + "target": "AnalyzerName" + }, + { + "source": "ruleName", + "target": "RuleName" + } + ], + "operation": "CreateArchiveRule", + "phase": "create", + "service": "accessanalyzer" + }, + { + "cfn_type": "AWS::AccessAnalyzer::ArchiveRule", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "analyzerName", + "target": "AnalyzerName" + }, + { + "source": "ruleName", + "target": "RuleName" + } + ], + "operation": "DeleteArchiveRule", + "phase": "delete", + "service": "accessanalyzer" + }, + { + "cfn_type": "AWS::AgentRegistry::Registry", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateRegistry", + "phase": "create", + "service": "agent-registry-control" + }, + { + "cfn_type": "AWS::AgentRegistry::Registry", + "mappings": [], + "operation": "DeleteRegistry", + "phase": "delete", + "service": "agent-registry-control" + }, + { + "cfn_type": "AWS::AgentRegistry::RegistryRecord", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "recordType", + "target": "RecordType" + }, + { + "source": "recordVersion", + "target": "RecordVersion" + }, + { + "source": "registryId", + "target": "RegistryId" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateRegistryRecord", + "phase": "create", + "service": "agent-registry-control" + }, + { + "cfn_type": "AWS::AgentRegistry::RegistryRecord", + "mappings": [ + { + "source": "registryId", + "target": "RegistryId" + } + ], + "operation": "DeleteRegistryRecord", + "phase": "delete", + "service": "agent-registry-control" + }, + { + "cfn_type": "AWS::AmazonMQ::Broker", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "AuthenticationStrategy", + "target": "AuthenticationStrategy" + }, + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "BrokerName", + "target": "BrokerName" + }, + { + "source": "DataReplicationMode", + "target": "DataReplicationMode" + }, + { + "source": "DataReplicationPrimaryBrokerArn", + "target": "DataReplicationPrimaryBrokerArn" + }, + { + "source": "DeploymentMode", + "target": "DeploymentMode" + }, + { + "source": "EngineType", + "target": "EngineType" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "HostInstanceType", + "target": "HostInstanceType" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "StorageSize", + "target": "StorageSize" + }, + { + "source": "StorageType", + "target": "StorageType" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateBroker", + "phase": "create", + "service": "mq" + }, + { + "cfn_type": "AWS::AmazonMQ::Broker", + "mappings": [], + "operation": "DeleteBroker", + "phase": "delete", + "service": "mq" + }, + { + "cfn_type": "AWS::AmazonMQ::Configuration", + "mappings": [ + { + "source": "AuthenticationStrategy", + "target": "AuthenticationStrategy" + }, + { + "source": "EngineType", + "target": "EngineType" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateConfiguration", + "phase": "create", + "service": "mq" + }, + { + "cfn_type": "AWS::AmazonMQ::Configuration", + "mappings": [], + "operation": "DeleteConfiguration", + "phase": "delete", + "service": "mq" + }, + { + "cfn_type": "AWS::Amplify::App", + "mappings": [ + { + "source": "accessToken", + "target": "AccessToken" + }, + { + "source": "buildSpec", + "target": "BuildSpec" + }, + { + "source": "computeRoleArn", + "target": "ComputeRoleArn" + }, + { + "source": "customHeaders", + "target": "CustomHeaders" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "enableBranchAutoDeletion", + "target": "EnableBranchAutoDeletion" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "oauthToken", + "target": "OauthToken" + }, + { + "source": "platform", + "target": "Platform" + }, + { + "source": "repository", + "target": "Repository" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateApp", + "phase": "create", + "service": "amplify" + }, + { + "cfn_type": "AWS::Amplify::App", + "mappings": [], + "operation": "DeleteApp", + "phase": "delete", + "service": "amplify" + }, + { + "cfn_type": "AWS::Amplify::Branch", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "branchName", + "target": "BranchName" + }, + { + "source": "buildSpec", + "target": "BuildSpec" + }, + { + "source": "computeRoleArn", + "target": "ComputeRoleArn" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "enableAutoBuild", + "target": "EnableAutoBuild" + }, + { + "source": "enablePerformanceMode", + "target": "EnablePerformanceMode" + }, + { + "source": "enablePullRequestPreview", + "target": "EnablePullRequestPreview" + }, + { + "source": "enableSkewProtection", + "target": "EnableSkewProtection" + }, + { + "source": "framework", + "target": "Framework" + }, + { + "source": "pullRequestEnvironmentName", + "target": "PullRequestEnvironmentName" + }, + { + "source": "stage", + "target": "Stage" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateBranch", + "phase": "create", + "service": "amplify" + }, + { + "cfn_type": "AWS::Amplify::Branch", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "branchName", + "target": "BranchName" + } + ], + "operation": "DeleteBranch", + "phase": "delete", + "service": "amplify" + }, + { + "cfn_type": "AWS::Amplify::Domain", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "autoSubDomainCreationPatterns", + "target": "AutoSubDomainCreationPatterns" + }, + { + "source": "autoSubDomainIAMRole", + "target": "AutoSubDomainIAMRole" + }, + { + "source": "domainName", + "target": "DomainName" + }, + { + "source": "enableAutoSubDomain", + "target": "EnableAutoSubDomain" + } + ], + "operation": "CreateDomainAssociation", + "phase": "create", + "service": "amplify" + }, + { + "cfn_type": "AWS::Amplify::Domain", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "domainName", + "target": "DomainName" + } + ], + "operation": "DeleteDomainAssociation", + "phase": "delete", + "service": "amplify" + }, + { + "cfn_type": "AWS::AmplifyUIBuilder::Component", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + } + ], + "operation": "CreateComponent", + "phase": "create", + "service": "amplifyuibuilder" + }, + { + "cfn_type": "AWS::AmplifyUIBuilder::Component", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + } + ], + "operation": "DeleteComponent", + "phase": "delete", + "service": "amplifyuibuilder" + }, + { + "cfn_type": "AWS::AmplifyUIBuilder::Form", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + } + ], + "operation": "CreateForm", + "phase": "create", + "service": "amplifyuibuilder" + }, + { + "cfn_type": "AWS::AmplifyUIBuilder::Form", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + } + ], + "operation": "DeleteForm", + "phase": "delete", + "service": "amplifyuibuilder" + }, + { + "cfn_type": "AWS::AmplifyUIBuilder::Theme", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + } + ], + "operation": "CreateTheme", + "phase": "create", + "service": "amplifyuibuilder" + }, + { + "cfn_type": "AWS::AmplifyUIBuilder::Theme", + "mappings": [ + { + "source": "appId", + "target": "AppId" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + } + ], + "operation": "DeleteTheme", + "phase": "delete", + "service": "amplifyuibuilder" + }, + { + "cfn_type": "AWS::ApiGatewayV2::PortalProduct", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePortalProduct", + "phase": "create", + "service": "apigatewayv2" + }, + { + "cfn_type": "AWS::ApiGatewayV2::PortalProduct", + "mappings": [], + "operation": "DeletePortalProduct", + "phase": "delete", + "service": "apigatewayv2" + }, + { + "cfn_type": "AWS::ApiGatewayV2::RoutingRule", + "mappings": [ + { + "source": "Priority", + "target": "Priority" + } + ], + "operation": "CreateRoutingRule", + "phase": "create", + "service": "apigatewayv2" + }, + { + "cfn_type": "AWS::ApiGatewayV2::RoutingRule", + "mappings": [], + "operation": "DeleteRoutingRule", + "phase": "delete", + "service": "apigatewayv2" + }, + { + "cfn_type": "AWS::AppConfig::Application", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::ConfigurationProfile", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "KmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "LocationUri", + "target": "LocationUri" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RetrievalRoleArn", + "target": "RetrievalRoleArn" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateConfigurationProfile", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::ConfigurationProfile", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "DeletionProtectionCheck", + "target": "DeletionProtectionCheck" + } + ], + "operation": "DeleteConfigurationProfile", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::Deployment", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "ConfigurationProfileId", + "target": "ConfigurationProfileId" + }, + { + "source": "ConfigurationVersion", + "target": "ConfigurationVersion" + }, + { + "source": "DeploymentStrategyId", + "target": "DeploymentStrategyId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnvironmentId", + "target": "EnvironmentId" + }, + { + "source": "KmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "StartDeployment", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::DeploymentStrategy", + "mappings": [ + { + "source": "DeploymentDurationInMinutes", + "target": "DeploymentDurationInMinutes" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "FinalBakeTimeInMinutes", + "target": "FinalBakeTimeInMinutes" + }, + { + "source": "GrowthFactor", + "target": "GrowthFactor" + }, + { + "source": "GrowthType", + "target": "GrowthType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ReplicateTo", + "target": "ReplicateTo" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDeploymentStrategy", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::DeploymentStrategy", + "mappings": [], + "operation": "DeleteDeploymentStrategy", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::Environment", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::Environment", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "DeletionProtectionCheck", + "target": "DeletionProtectionCheck" + } + ], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::ExperimentDefinition", + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "AudienceDescription", + "target": "AudienceDescription" + }, + { + "source": "AudienceRule", + "target": "AudienceRule" + }, + { + "source": "ConfigurationProfileIdentifier", + "target": "ConfigurationProfileIdentifier" + }, + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "FlagKey", + "target": "FlagKey" + }, + { + "source": "Hypothesis", + "target": "Hypothesis" + }, + { + "source": "LaunchCriteria", + "target": "LaunchCriteria" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateExperimentDefinition", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::ExperimentDefinition", + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + } + ], + "operation": "DeleteExperimentDefinition", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::Extension", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "LatestVersionNumber", + "target": "LatestVersionNumber" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateExtension", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::Extension", + "mappings": [], + "operation": "DeleteExtension", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::ExtensionAssociation", + "mappings": [ + { + "source": "ExtensionIdentifier", + "target": "ExtensionIdentifier" + }, + { + "source": "ExtensionVersionNumber", + "target": "ExtensionVersionNumber" + }, + { + "source": "ResourceIdentifier", + "target": "ResourceIdentifier" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateExtensionAssociation", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::ExtensionAssociation", + "mappings": [], + "operation": "DeleteExtensionAssociation", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::HostedConfigurationVersion", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "ConfigurationProfileId", + "target": "ConfigurationProfileId" + }, + { + "source": "ContentType", + "target": "ContentType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "LatestVersionNumber", + "target": "LatestVersionNumber" + }, + { + "source": "VersionLabel", + "target": "VersionLabel" + } + ], + "operation": "CreateHostedConfigurationVersion", + "phase": "create", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppConfig::HostedConfigurationVersion", + "mappings": [ + { + "source": "ApplicationId", + "target": "ApplicationId" + }, + { + "source": "ConfigurationProfileId", + "target": "ConfigurationProfileId" + } + ], + "operation": "DeleteHostedConfigurationVersion", + "phase": "delete", + "service": "appconfig" + }, + { + "cfn_type": "AWS::AppFlow::Connector", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "connectorLabel", + "target": "ConnectorLabel" + }, + { + "source": "connectorProvisioningType", + "target": "ConnectorProvisioningType" + }, + { + "source": "description", + "target": "Description" + } + ], + "operation": "RegisterConnector", + "phase": "create", + "service": "appflow" + }, + { + "cfn_type": "AWS::AppFlow::ConnectorProfile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "connectionMode", + "target": "ConnectionMode" + }, + { + "source": "connectorLabel", + "target": "ConnectorLabel" + }, + { + "source": "connectorProfileName", + "target": "ConnectorProfileName" + }, + { + "source": "connectorType", + "target": "ConnectorType" + }, + { + "source": "kmsArn", + "target": "KMSArn" + } + ], + "operation": "CreateConnectorProfile", + "phase": "create", + "service": "appflow" + }, + { + "cfn_type": "AWS::AppFlow::ConnectorProfile", + "mappings": [ + { + "source": "connectorProfileName", + "target": "ConnectorProfileName" + } + ], + "operation": "DeleteConnectorProfile", + "phase": "delete", + "service": "appflow" + }, + { + "cfn_type": "AWS::AppFlow::Flow", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "flowName", + "target": "FlowName" + }, + { + "source": "kmsArn", + "target": "KMSArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateFlow", + "phase": "create", + "service": "appflow" + }, + { + "cfn_type": "AWS::AppFlow::Flow", + "mappings": [ + { + "source": "flowName", + "target": "FlowName" + } + ], + "operation": "DeleteFlow", + "phase": "delete", + "service": "appflow" + }, + { + "cfn_type": "AWS::AppIntegrations::Application", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ApplicationType", + "target": "ApplicationType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "InitializationTimeout", + "target": "InitializationTimeout" + }, + { + "source": "IsService", + "target": "IsService" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Namespace", + "target": "Namespace" + }, + { + "source": "Permissions", + "target": "Permissions" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "appintegrations" + }, + { + "cfn_type": "AWS::AppIntegrations::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "appintegrations" + }, + { + "cfn_type": "AWS::AppIntegrations::DataIntegration", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "KmsKey", + "target": "KmsKey" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SourceURI", + "target": "SourceURI" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDataIntegration", + "phase": "create", + "service": "appintegrations" + }, + { + "cfn_type": "AWS::AppIntegrations::DataIntegration", + "mappings": [], + "operation": "DeleteDataIntegration", + "phase": "delete", + "service": "appintegrations" + }, + { + "cfn_type": "AWS::AppIntegrations::EventIntegration", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventBridgeBus", + "target": "EventBridgeBus" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateEventIntegration", + "phase": "create", + "service": "appintegrations" + }, + { + "cfn_type": "AWS::AppIntegrations::EventIntegration", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteEventIntegration", + "phase": "delete", + "service": "appintegrations" + }, + { + "cfn_type": "AWS::AppRunner::AutoScalingConfiguration", + "mappings": [ + { + "source": "AutoScalingConfigurationName", + "target": "AutoScalingConfigurationName" + }, + { + "source": "MaxConcurrency", + "target": "MaxConcurrency" + }, + { + "source": "MaxSize", + "target": "MaxSize" + }, + { + "source": "MinSize", + "target": "MinSize" + } + ], + "operation": "CreateAutoScalingConfiguration", + "phase": "create", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::AutoScalingConfiguration", + "mappings": [], + "operation": "DeleteAutoScalingConfiguration", + "phase": "delete", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::ObservabilityConfiguration", + "mappings": [ + { + "source": "ObservabilityConfigurationName", + "target": "ObservabilityConfigurationName" + } + ], + "operation": "CreateObservabilityConfiguration", + "phase": "create", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::ObservabilityConfiguration", + "mappings": [], + "operation": "DeleteObservabilityConfiguration", + "phase": "delete", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::Service", + "mappings": [ + { + "source": "AutoScalingConfigurationArn", + "target": "AutoScalingConfigurationArn" + }, + { + "source": "ServiceName", + "target": "ServiceName" + } + ], + "operation": "CreateService", + "phase": "create", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::Service", + "mappings": [], + "operation": "DeleteService", + "phase": "delete", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::VpcConnector", + "mappings": [ + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "Subnets", + "target": "Subnets" + }, + { + "source": "VpcConnectorName", + "target": "VpcConnectorName" + } + ], + "operation": "CreateVpcConnector", + "phase": "create", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::VpcConnector", + "mappings": [], + "operation": "DeleteVpcConnector", + "phase": "delete", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::VpcIngressConnection", + "mappings": [ + { + "source": "ServiceArn", + "target": "ServiceArn" + }, + { + "source": "VpcIngressConnectionName", + "target": "VpcIngressConnectionName" + } + ], + "operation": "CreateVpcIngressConnection", + "phase": "create", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppRunner::VpcIngressConnection", + "mappings": [], + "operation": "DeleteVpcIngressConnection", + "phase": "delete", + "service": "apprunner" + }, + { + "cfn_type": "AWS::AppStream::AppBlock", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PackagingType", + "target": "PackagingType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateAppBlock", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::AppBlock", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteAppBlock", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::AppBlockBuilder", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "EnableDefaultInternetAccess", + "target": "EnableDefaultInternetAccess" + }, + { + "source": "IamRoleArn", + "target": "IamRoleArn" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Platform", + "target": "Platform" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateAppBlockBuilder", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::AppBlockBuilder", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteAppBlockBuilder", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::Application", + "mappings": [ + { + "source": "AppBlockArn", + "target": "AppBlockArn" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "InstanceFamilies", + "target": "InstanceFamilies" + }, + { + "source": "LaunchParameters", + "target": "LaunchParameters" + }, + { + "source": "LaunchPath", + "target": "LaunchPath" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Platforms", + "target": "Platforms" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "WorkingDirectory", + "target": "WorkingDirectory" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::Application", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteApplication", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::ApplicationEntitlementAssociation", + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "EntitlementName", + "target": "EntitlementName" + }, + { + "source": "StackName", + "target": "StackName" + } + ], + "operation": "AssociateApplicationToEntitlement", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::ApplicationEntitlementAssociation", + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "EntitlementName", + "target": "EntitlementName" + }, + { + "source": "StackName", + "target": "StackName" + } + ], + "operation": "DisassociateApplicationFromEntitlement", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::ApplicationFleetAssociation", + "mappings": [ + { + "source": "ApplicationArn", + "target": "ApplicationArn" + }, + { + "source": "FleetName", + "target": "FleetName" + } + ], + "operation": "AssociateApplicationFleet", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::ApplicationFleetAssociation", + "mappings": [ + { + "source": "ApplicationArn", + "target": "ApplicationArn" + }, + { + "source": "FleetName", + "target": "FleetName" + } + ], + "operation": "DisassociateApplicationFleet", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::DirectoryConfig", + "mappings": [ + { + "source": "DirectoryName", + "target": "DirectoryName" + }, + { + "source": "OrganizationalUnitDistinguishedNames", + "target": "OrganizationalUnitDistinguishedNames" + } + ], + "operation": "CreateDirectoryConfig", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::DirectoryConfig", + "mappings": [ + { + "source": "DirectoryName", + "target": "DirectoryName" + } + ], + "operation": "DeleteDirectoryConfig", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::Entitlement", + "mappings": [ + { + "source": "AppVisibility", + "target": "AppVisibility" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "StackName", + "target": "StackName" + } + ], + "operation": "CreateEntitlement", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::Entitlement", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "StackName", + "target": "StackName" + } + ], + "operation": "DeleteEntitlement", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::ImageBuilder", + "mappings": [ + { + "source": "AppstreamAgentVersion", + "target": "AppstreamAgentVersion" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "EnableDefaultInternetAccess", + "target": "EnableDefaultInternetAccess" + }, + { + "source": "IamRoleArn", + "target": "IamRoleArn" + }, + { + "source": "ImageArn", + "target": "ImageArn" + }, + { + "source": "ImageName", + "target": "ImageName" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SoftwaresToInstall", + "target": "SoftwaresToInstall" + }, + { + "source": "SoftwaresToUninstall", + "target": "SoftwaresToUninstall" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateImageBuilder", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::ImageBuilder", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteImageBuilder", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::Stack", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "EmbedHostDomains", + "target": "EmbedHostDomains" + }, + { + "source": "FeedbackURL", + "target": "FeedbackURL" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RedirectURL", + "target": "RedirectURL" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateStack", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::Stack", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteStack", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::User", + "mappings": [ + { + "source": "AuthenticationType", + "target": "AuthenticationType" + }, + { + "source": "FirstName", + "target": "FirstName" + }, + { + "source": "LastName", + "target": "LastName" + }, + { + "source": "MessageAction", + "target": "MessageAction" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "CreateUser", + "phase": "create", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppStream::User", + "mappings": [ + { + "source": "AuthenticationType", + "target": "AuthenticationType" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "DeleteUser", + "phase": "delete", + "service": "appstream" + }, + { + "cfn_type": "AWS::AppSync::Api", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "ownerContact", + "target": "OwnerContact" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateApi", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::Api", + "mappings": [], + "operation": "DeleteApi", + "phase": "delete", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::ChannelNamespace", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "codeHandlers", + "target": "CodeHandlers" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateChannelNamespace", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::ChannelNamespace", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteChannelNamespace", + "phase": "delete", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::DataSource", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "metricsConfig", + "target": "MetricsConfig" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "serviceRoleArn", + "target": "ServiceRoleArn" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateDataSource", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::DataSource", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::DomainName", + "mappings": [ + { + "source": "certificateArn", + "target": "CertificateArn" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "domainName", + "target": "DomainName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDomainName", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::DomainName", + "mappings": [ + { + "source": "domainName", + "target": "DomainName" + } + ], + "operation": "DeleteDomainName", + "phase": "delete", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::DomainNameApiAssociation", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "domainName", + "target": "DomainName" + } + ], + "operation": "AssociateApi", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::FunctionConfiguration", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "code", + "target": "Code" + }, + { + "source": "dataSourceName", + "target": "DataSourceName" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "functionVersion", + "target": "FunctionVersion" + }, + { + "source": "maxBatchSize", + "target": "MaxBatchSize" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "requestMappingTemplate", + "target": "RequestMappingTemplate" + }, + { + "source": "responseMappingTemplate", + "target": "ResponseMappingTemplate" + } + ], + "operation": "CreateFunction", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::GraphQLApi", + "mappings": [ + { + "source": "apiType", + "target": "ApiType" + }, + { + "source": "authenticationType", + "target": "AuthenticationType" + }, + { + "source": "introspectionConfig", + "target": "IntrospectionConfig" + }, + { + "source": "mergedApiExecutionRoleArn", + "target": "MergedApiExecutionRoleArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "ownerContact", + "target": "OwnerContact" + }, + { + "source": "queryDepthLimit", + "target": "QueryDepthLimit" + }, + { + "source": "resolverCountLimit", + "target": "ResolverCountLimit" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "visibility", + "target": "Visibility" + }, + { + "source": "xrayEnabled", + "target": "XrayEnabled" + } + ], + "operation": "CreateGraphqlApi", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::GraphQLApi", + "mappings": [], + "operation": "DeleteGraphqlApi", + "phase": "delete", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::Resolver", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "code", + "target": "Code" + }, + { + "source": "dataSourceName", + "target": "DataSourceName" + }, + { + "source": "fieldName", + "target": "FieldName" + }, + { + "source": "kind", + "target": "Kind" + }, + { + "source": "maxBatchSize", + "target": "MaxBatchSize" + }, + { + "source": "metricsConfig", + "target": "MetricsConfig" + }, + { + "source": "requestMappingTemplate", + "target": "RequestMappingTemplate" + }, + { + "source": "responseMappingTemplate", + "target": "ResponseMappingTemplate" + }, + { + "source": "typeName", + "target": "TypeName" + } + ], + "operation": "CreateResolver", + "phase": "create", + "service": "appsync" + }, + { + "cfn_type": "AWS::AppSync::Resolver", + "mappings": [ + { + "source": "apiId", + "target": "ApiId" + }, + { + "source": "fieldName", + "target": "FieldName" + }, + { + "source": "typeName", + "target": "TypeName" + } + ], + "operation": "DeleteResolver", + "phase": "delete", + "service": "appsync" + }, + { + "cfn_type": "AWS::ApplicationAutoScaling::ScalableTarget", + "mappings": [ + { + "source": "MaxCapacity", + "target": "MaxCapacity" + }, + { + "source": "MinCapacity", + "target": "MinCapacity" + }, + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "RoleARN", + "target": "RoleARN" + }, + { + "source": "ScalableDimension", + "target": "ScalableDimension" + }, + { + "source": "ServiceNamespace", + "target": "ServiceNamespace" + } + ], + "operation": "RegisterScalableTarget", + "phase": "create", + "service": "application-autoscaling" + }, + { + "cfn_type": "AWS::ApplicationAutoScaling::ScalableTarget", + "mappings": [ + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "ScalableDimension", + "target": "ScalableDimension" + }, + { + "source": "ServiceNamespace", + "target": "ServiceNamespace" + } + ], + "operation": "DeregisterScalableTarget", + "phase": "delete", + "service": "application-autoscaling" + }, + { + "cfn_type": "AWS::ApplicationAutoScaling::ScalingPolicy", + "mappings": [ + { + "source": "PolicyName", + "target": "PolicyName" + }, + { + "source": "PolicyType", + "target": "PolicyType" + }, + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "ScalableDimension", + "target": "ScalableDimension" + }, + { + "source": "ServiceNamespace", + "target": "ServiceNamespace" + } + ], + "operation": "PutScalingPolicy", + "phase": "create", + "service": "application-autoscaling" + }, + { + "cfn_type": "AWS::ApplicationAutoScaling::ScalingPolicy", + "mappings": [ + { + "source": "PolicyName", + "target": "PolicyName" + }, + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "ScalableDimension", + "target": "ScalableDimension" + }, + { + "source": "ServiceNamespace", + "target": "ServiceNamespace" + } + ], + "operation": "DeleteScalingPolicy", + "phase": "delete", + "service": "application-autoscaling" + }, + { + "cfn_type": "AWS::ApplicationInsights::Application", + "mappings": [ + { + "source": "AttachMissingPermission", + "target": "AttachMissingPermission" + }, + { + "source": "CWEMonitorEnabled", + "target": "CWEMonitorEnabled" + }, + { + "source": "GroupingType", + "target": "GroupingType" + }, + { + "source": "OpsCenterEnabled", + "target": "OpsCenterEnabled" + }, + { + "source": "OpsItemSNSTopicArn", + "target": "OpsItemSNSTopicArn" + }, + { + "source": "ResourceGroupName", + "target": "ResourceGroupName" + }, + { + "source": "SNSNotificationArn", + "target": "SNSNotificationArn" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "application-insights" + }, + { + "cfn_type": "AWS::ApplicationInsights::Application", + "mappings": [ + { + "source": "ResourceGroupName", + "target": "ResourceGroupName" + } + ], + "operation": "DeleteApplication", + "phase": "delete", + "service": "application-insights" + }, + { + "cfn_type": "AWS::ApplicationSignals::GroupingConfiguration", + "mappings": [], + "operation": "DeleteGroupingConfiguration", + "phase": "delete", + "service": "application-signals" + }, + { + "cfn_type": "AWS::ApplicationSignals::ServiceLevelObjective", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateServiceLevelObjective", + "phase": "create", + "service": "application-signals" + }, + { + "cfn_type": "AWS::ApplicationSignals::ServiceLevelObjective", + "mappings": [], + "operation": "DeleteServiceLevelObjective", + "phase": "delete", + "service": "application-signals" + }, + { + "cfn_type": "AWS::Athena::CapacityReservation", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "TargetDpus", + "target": "TargetDpus" + } + ], + "operation": "CreateCapacityReservation", + "phase": "create", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::CapacityReservation", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteCapacityReservation", + "phase": "delete", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::DataCatalog", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateDataCatalog", + "phase": "create", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::DataCatalog", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteDataCatalog", + "phase": "delete", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::NamedQuery", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Database", + "target": "Database" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "QueryString", + "target": "QueryString" + }, + { + "source": "WorkGroup", + "target": "WorkGroup" + } + ], + "operation": "CreateNamedQuery", + "phase": "create", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::NamedQuery", + "ignored_inputs": [ + "NamedQueryId" + ], + "mappings": [], + "operation": "DeleteNamedQuery", + "phase": "delete", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::PreparedStatement", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "QueryStatement", + "target": "QueryStatement" + }, + { + "source": "StatementName", + "target": "StatementName" + }, + { + "source": "WorkGroup", + "target": "WorkGroup" + } + ], + "operation": "CreatePreparedStatement", + "phase": "create", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::PreparedStatement", + "mappings": [ + { + "source": "StatementName", + "target": "StatementName" + }, + { + "source": "WorkGroup", + "target": "WorkGroup" + } + ], + "operation": "DeletePreparedStatement", + "phase": "delete", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::WorkGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateWorkGroup", + "phase": "create", + "service": "athena" + }, + { + "cfn_type": "AWS::Athena::WorkGroup", + "mappings": [ + { + "source": "RecursiveDeleteOption", + "target": "RecursiveDeleteOption" + } + ], + "operation": "DeleteWorkGroup", + "phase": "delete", + "service": "athena" + }, + { + "cfn_type": "AWS::AuditManager::Assessment", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "frameworkId", + "target": "FrameworkId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAssessment", + "phase": "create", + "service": "auditmanager" + }, + { + "cfn_type": "AWS::AuditManager::Assessment", + "mappings": [], + "operation": "DeleteAssessment", + "phase": "delete", + "service": "auditmanager" + }, + { + "cfn_type": "AWS::AuditManager::AssessmentFramework", + "mappings": [ + { + "source": "complianceType", + "target": "ComplianceType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAssessmentFramework", + "phase": "create", + "service": "auditmanager" + }, + { + "cfn_type": "AWS::AuditManager::AssessmentFramework", + "mappings": [], + "operation": "DeleteAssessmentFramework", + "phase": "delete", + "service": "auditmanager" + }, + { + "cfn_type": "AWS::AuditManager::Control", + "mappings": [ + { + "source": "actionPlanInstructions", + "target": "ActionPlanInstructions" + }, + { + "source": "actionPlanTitle", + "target": "ActionPlanTitle" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "testingInformation", + "target": "TestingInformation" + } + ], + "operation": "CreateControl", + "phase": "create", + "service": "auditmanager" + }, + { + "cfn_type": "AWS::AuditManager::Control", + "mappings": [], + "operation": "DeleteControl", + "phase": "delete", + "service": "auditmanager" + }, + { + "cfn_type": "AWS::AutoScaling::AutoScalingGroup", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + }, + { + "source": "AvailabilityZoneIds", + "target": "AvailabilityZoneIds" + }, + { + "source": "AvailabilityZones", + "target": "AvailabilityZones" + }, + { + "source": "CapacityRebalance", + "target": "CapacityRebalance" + }, + { + "source": "Context", + "target": "Context" + }, + { + "source": "DefaultInstanceWarmup", + "target": "DefaultInstanceWarmup" + }, + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "DesiredCapacityType", + "target": "DesiredCapacityType" + }, + { + "source": "HealthCheckGracePeriod", + "target": "HealthCheckGracePeriod" + }, + { + "source": "HealthCheckType", + "target": "HealthCheckType" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "LaunchConfigurationName", + "target": "LaunchConfigurationName" + }, + { + "source": "LoadBalancerNames", + "target": "LoadBalancerNames" + }, + { + "source": "MaxInstanceLifetime", + "target": "MaxInstanceLifetime" + }, + { + "source": "NewInstancesProtectedFromScaleIn", + "target": "NewInstancesProtectedFromScaleIn" + }, + { + "source": "PlacementGroup", + "target": "PlacementGroup" + }, + { + "source": "ServiceLinkedRoleARN", + "target": "ServiceLinkedRoleARN" + }, + { + "source": "SkipZonalShiftValidation", + "target": "SkipZonalShiftValidation" + }, + { + "source": "TargetGroupARNs", + "target": "TargetGroupARNs" + }, + { + "source": "TerminationPolicies", + "target": "TerminationPolicies" + } + ], + "operation": "CreateAutoScalingGroup", + "phase": "create", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::AutoScalingGroup", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + } + ], + "operation": "DeleteAutoScalingGroup", + "phase": "delete", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::LaunchConfiguration", + "mappings": [ + { + "source": "AssociatePublicIpAddress", + "target": "AssociatePublicIpAddress" + }, + { + "source": "ClassicLinkVPCId", + "target": "ClassicLinkVPCId" + }, + { + "source": "ClassicLinkVPCSecurityGroups", + "target": "ClassicLinkVPCSecurityGroups" + }, + { + "source": "EbsOptimized", + "target": "EbsOptimized" + }, + { + "source": "IamInstanceProfile", + "target": "IamInstanceProfile" + }, + { + "source": "ImageId", + "target": "ImageId" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "KernelId", + "target": "KernelId" + }, + { + "source": "KeyName", + "target": "KeyName" + }, + { + "source": "LaunchConfigurationName", + "target": "LaunchConfigurationName" + }, + { + "source": "PlacementTenancy", + "target": "PlacementTenancy" + }, + { + "source": "RamdiskId", + "target": "RamDiskId" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "SpotPrice", + "target": "SpotPrice" + }, + { + "source": "UserData", + "target": "UserData" + } + ], + "operation": "CreateLaunchConfiguration", + "phase": "create", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::LaunchConfiguration", + "mappings": [ + { + "source": "LaunchConfigurationName", + "target": "LaunchConfigurationName" + } + ], + "operation": "DeleteLaunchConfiguration", + "phase": "delete", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::LifecycleHook", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + }, + { + "source": "DefaultResult", + "target": "DefaultResult" + }, + { + "source": "HeartbeatTimeout", + "target": "HeartbeatTimeout" + }, + { + "source": "LifecycleHookName", + "target": "LifecycleHookName" + }, + { + "source": "LifecycleTransition", + "target": "LifecycleTransition" + }, + { + "source": "NotificationMetadata", + "target": "NotificationMetadata" + }, + { + "source": "NotificationTargetARN", + "target": "NotificationTargetARN" + }, + { + "source": "RoleARN", + "target": "RoleARN" + } + ], + "operation": "PutLifecycleHook", + "phase": "create", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::LifecycleHook", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + }, + { + "source": "LifecycleHookName", + "target": "LifecycleHookName" + } + ], + "operation": "DeleteLifecycleHook", + "phase": "delete", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::ScalingPolicy", + "mappings": [ + { + "source": "AdjustmentType", + "target": "AdjustmentType" + }, + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + }, + { + "source": "EstimatedInstanceWarmup", + "target": "EstimatedInstanceWarmup" + }, + { + "source": "MetricAggregationType", + "target": "MetricAggregationType" + }, + { + "source": "MinAdjustmentMagnitude", + "target": "MinAdjustmentMagnitude" + }, + { + "source": "PolicyType", + "target": "PolicyType" + }, + { + "source": "ScalingAdjustment", + "target": "ScalingAdjustment" + } + ], + "operation": "PutScalingPolicy", + "phase": "create", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::ScheduledAction", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + }, + { + "source": "DesiredCapacity", + "target": "DesiredCapacity" + }, + { + "source": "MaxSize", + "target": "MaxSize" + }, + { + "source": "MinSize", + "target": "MinSize" + }, + { + "source": "Recurrence", + "target": "Recurrence" + }, + { + "source": "TimeZone", + "target": "TimeZone" + } + ], + "operation": "PutScheduledUpdateGroupAction", + "phase": "create", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::ScheduledAction", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + } + ], + "operation": "DeleteScheduledAction", + "phase": "delete", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::WarmPool", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + }, + { + "source": "MaxGroupPreparedCapacity", + "target": "MaxGroupPreparedCapacity" + }, + { + "source": "MinSize", + "target": "MinSize" + }, + { + "source": "PoolState", + "target": "PoolState" + } + ], + "operation": "PutWarmPool", + "phase": "create", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::AutoScaling::WarmPool", + "mappings": [ + { + "source": "AutoScalingGroupName", + "target": "AutoScalingGroupName" + } + ], + "operation": "DeleteWarmPool", + "phase": "delete", + "service": "autoscaling" + }, + { + "cfn_type": "AWS::B2BI::Capability", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateCapability", + "phase": "create", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Capability", + "mappings": [], + "operation": "DeleteCapability", + "phase": "delete", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Partnership", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "capabilities", + "target": "Capabilities" + }, + { + "source": "email", + "target": "Email" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "phone", + "target": "Phone" + }, + { + "source": "profileId", + "target": "ProfileId" + } + ], + "operation": "CreatePartnership", + "phase": "create", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Partnership", + "mappings": [], + "operation": "DeletePartnership", + "phase": "delete", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Profile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "businessName", + "target": "BusinessName" + }, + { + "source": "email", + "target": "Email" + }, + { + "source": "logging", + "target": "Logging" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "phone", + "target": "Phone" + } + ], + "operation": "CreateProfile", + "phase": "create", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Profile", + "mappings": [], + "operation": "DeleteProfile", + "phase": "delete", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Transformer", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "fileFormat", + "target": "FileFormat" + }, + { + "source": "mappingTemplate", + "target": "MappingTemplate" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "sampleDocument", + "target": "SampleDocument" + } + ], + "operation": "CreateTransformer", + "phase": "create", + "service": "b2bi" + }, + { + "cfn_type": "AWS::B2BI::Transformer", + "mappings": [], + "operation": "DeleteTransformer", + "phase": "delete", + "service": "b2bi" + }, + { + "cfn_type": "AWS::BCM::Dashboard", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateDashboard", + "phase": "create", + "service": "bcm-dashboards" + }, + { + "cfn_type": "AWS::BCM::Dashboard", + "mappings": [], + "operation": "DeleteDashboard", + "phase": "delete", + "service": "bcm-dashboards" + }, + { + "cfn_type": "AWS::BCMDataExports::Export", + "mappings": [], + "operation": "DeleteExport", + "phase": "delete", + "service": "bcm-data-exports" + }, + { + "cfn_type": "AWS::Backup::BackupPlan", + "mappings": [], + "operation": "DeleteBackupPlan", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::BackupSelection", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "BackupPlanId", + "target": "BackupPlanId" + } + ], + "operation": "CreateBackupSelection", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::BackupSelection", + "mappings": [ + { + "source": "BackupPlanId", + "target": "BackupPlanId" + } + ], + "operation": "DeleteBackupSelection", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::BackupVault", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "BackupVaultName", + "target": "BackupVaultName" + }, + { + "source": "EncryptionKeyArn", + "target": "EncryptionKeyArn" + } + ], + "operation": "CreateBackupVault", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::BackupVault", + "mappings": [ + { + "source": "BackupVaultName", + "target": "BackupVaultName" + } + ], + "operation": "DeleteBackupVault", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::Framework", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "FrameworkDescription", + "target": "FrameworkDescription" + }, + { + "source": "FrameworkName", + "target": "FrameworkName" + } + ], + "operation": "CreateFramework", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::Framework", + "mappings": [ + { + "source": "FrameworkName", + "target": "FrameworkName" + } + ], + "operation": "DeleteFramework", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::LegalHold", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Title", + "target": "Title" + } + ], + "operation": "CreateLegalHold", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::LegalHold", + "mappings": [], + "operation": "CancelLegalHold", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::LogicallyAirGappedBackupVault", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "BackupVaultName", + "target": "BackupVaultName" + }, + { + "source": "EncryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "MaxRetentionDays", + "target": "MaxRetentionDays" + }, + { + "source": "MinRetentionDays", + "target": "MinRetentionDays" + } + ], + "operation": "CreateLogicallyAirGappedBackupVault", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::ReportPlan", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "ReportPlanDescription", + "target": "ReportPlanDescription" + }, + { + "source": "ReportPlanName", + "target": "ReportPlanName" + } + ], + "operation": "CreateReportPlan", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::ReportPlan", + "mappings": [ + { + "source": "ReportPlanName", + "target": "ReportPlanName" + } + ], + "operation": "DeleteReportPlan", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::RestoreTestingPlan", + "mappings": [ + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRestoreTestingPlan", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::RestoreTestingPlan", + "mappings": [ + { + "source": "RestoreTestingPlanName", + "target": "RestoreTestingPlanName" + } + ], + "operation": "DeleteRestoreTestingPlan", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::RestoreTestingSelection", + "mappings": [ + { + "source": "RestoreTestingPlanName", + "target": "RestoreTestingPlanName" + } + ], + "operation": "CreateRestoreTestingSelection", + "phase": "create", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::RestoreTestingSelection", + "mappings": [ + { + "source": "RestoreTestingPlanName", + "target": "RestoreTestingPlanName" + }, + { + "source": "RestoreTestingSelectionName", + "target": "RestoreTestingSelectionName" + } + ], + "operation": "DeleteRestoreTestingSelection", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::Backup::TieringConfiguration", + "mappings": [ + { + "source": "TieringConfigurationName", + "target": "TieringConfigurationName" + } + ], + "operation": "DeleteTieringConfiguration", + "phase": "delete", + "service": "backup" + }, + { + "cfn_type": "AWS::BackupGateway::Hypervisor", + "mappings": [ + { + "source": "Host", + "target": "Host" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Password", + "target": "Password" + }, + { + "source": "Username", + "target": "Username" + } + ], + "operation": "ImportHypervisorConfiguration", + "phase": "create", + "service": "backup-gateway" + }, + { + "cfn_type": "AWS::BackupGateway::Hypervisor", + "mappings": [], + "operation": "DeleteHypervisor", + "phase": "delete", + "service": "backup-gateway" + }, + { + "cfn_type": "AWS::Batch::ComputeEnvironment", + "mappings": [ + { + "source": "computeEnvironmentName", + "target": "ComputeEnvironmentName" + }, + { + "source": "context", + "target": "Context" + }, + { + "source": "serviceRole", + "target": "ServiceRole" + }, + { + "source": "state", + "target": "State" + }, + { + "source": "type", + "target": "Type" + }, + { + "source": "unmanagedvCpus", + "target": "UnmanagedvCpus" + } + ], + "operation": "CreateComputeEnvironment", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::ComputeEnvironment", + "mappings": [ + { + "source": "computeEnvironment", + "target": "ComputeEnvironmentName" + } + ], + "operation": "DeleteComputeEnvironment", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::ConsumableResource", + "mappings": [ + { + "source": "consumableResourceName", + "target": "ConsumableResourceName" + }, + { + "source": "resourceType", + "target": "ResourceType" + }, + { + "source": "totalQuantity", + "target": "TotalQuantity" + } + ], + "operation": "CreateConsumableResource", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::ConsumableResource", + "mappings": [ + { + "source": "consumableResource", + "target": "ConsumableResourceName" + } + ], + "operation": "DeleteConsumableResource", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::JobDefinition", + "mappings": [ + { + "source": "jobDefinitionName", + "target": "JobDefinitionName" + }, + { + "source": "platformCapabilities", + "target": "PlatformCapabilities" + }, + { + "source": "propagateTags", + "target": "PropagateTags" + }, + { + "source": "schedulingPriority", + "target": "SchedulingPriority" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "RegisterJobDefinition", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::JobDefinition", + "mappings": [ + { + "source": "jobDefinition", + "target": "JobDefinitionName" + } + ], + "operation": "DeregisterJobDefinition", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::JobQueue", + "mappings": [ + { + "source": "jobQueueName", + "target": "JobQueueName" + }, + { + "source": "jobQueueType", + "target": "JobQueueType" + }, + { + "source": "priority", + "target": "Priority" + }, + { + "source": "schedulingPolicyArn", + "target": "SchedulingPolicyArn" + }, + { + "source": "state", + "target": "State" + } + ], + "operation": "CreateJobQueue", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::JobQueue", + "mappings": [ + { + "source": "jobQueue", + "target": "JobQueueName" + } + ], + "operation": "DeleteJobQueue", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::QuotaShare", + "mappings": [ + { + "source": "jobQueue", + "target": "JobQueue" + }, + { + "source": "quotaShareName", + "target": "QuotaShareName" + }, + { + "source": "state", + "target": "State" + } + ], + "operation": "CreateQuotaShare", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::QuotaShare", + "mappings": [], + "operation": "DeleteQuotaShare", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::SchedulingPolicy", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateSchedulingPolicy", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::SchedulingPolicy", + "mappings": [], + "operation": "DeleteSchedulingPolicy", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::ServiceEnvironment", + "mappings": [ + { + "source": "serviceEnvironmentName", + "target": "ServiceEnvironmentName" + }, + { + "source": "serviceEnvironmentType", + "target": "ServiceEnvironmentType" + }, + { + "source": "state", + "target": "State" + } + ], + "operation": "CreateServiceEnvironment", + "phase": "create", + "service": "batch" + }, + { + "cfn_type": "AWS::Batch::ServiceEnvironment", + "mappings": [ + { + "source": "serviceEnvironment", + "target": "ServiceEnvironmentName" + } + ], + "operation": "DeleteServiceEnvironment", + "phase": "delete", + "service": "batch" + }, + { + "cfn_type": "AWS::BcmPricingCalculator::BillScenario", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "costCategoryGroupSharingPreferenceArn", + "target": "CostCategoryGroupSharingPreferenceArn" + }, + { + "source": "groupSharingPreference", + "target": "GroupSharingPreference" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateBillScenario", + "phase": "create", + "service": "bcm-pricing-calculator" + }, + { + "cfn_type": "AWS::BcmPricingCalculator::BillScenario", + "mappings": [], + "operation": "DeleteBillScenario", + "phase": "delete", + "service": "bcm-pricing-calculator" + }, + { + "cfn_type": "AWS::Bedrock::AgentAlias", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "agentAliasName", + "target": "AgentAliasName" + }, + { + "source": "agentId", + "target": "AgentId" + }, + { + "source": "description", + "target": "Description" + } + ], + "operation": "CreateAgentAlias", + "phase": "create", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::AgentAlias", + "mappings": [ + { + "source": "agentId", + "target": "AgentId" + } + ], + "operation": "DeleteAgentAlias", + "phase": "delete", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::ApplicationInferenceProfile", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "inferenceProfileName", + "target": "InferenceProfileName" + } + ], + "operation": "CreateInferenceProfile", + "phase": "create", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::AutomatedReasoningPolicy", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateAutomatedReasoningPolicy", + "phase": "create", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::AutomatedReasoningPolicy", + "mappings": [], + "operation": "DeleteAutomatedReasoningPolicy", + "phase": "delete", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::AutomatedReasoningPolicyVersion", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "lastUpdatedDefinitionHash", + "target": "LastUpdatedDefinitionHash" + }, + { + "source": "policyArn", + "target": "PolicyArn" + } + ], + "operation": "CreateAutomatedReasoningPolicyVersion", + "phase": "create", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::Blueprint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "blueprintName", + "target": "BlueprintName" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateBlueprint", + "phase": "create", + "service": "bedrock-data-automation" + }, + { + "cfn_type": "AWS::Bedrock::Blueprint", + "mappings": [], + "operation": "DeleteBlueprint", + "phase": "delete", + "service": "bedrock-data-automation" + }, + { + "cfn_type": "AWS::Bedrock::DataAutomationLibrary", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "libraryDescription", + "target": "LibraryDescription" + }, + { + "source": "libraryName", + "target": "LibraryName" + } + ], + "operation": "CreateDataAutomationLibrary", + "phase": "create", + "service": "bedrock-data-automation" + }, + { + "cfn_type": "AWS::Bedrock::DataAutomationLibrary", + "mappings": [], + "operation": "DeleteDataAutomationLibrary", + "phase": "delete", + "service": "bedrock-data-automation" + }, + { + "cfn_type": "AWS::Bedrock::DataAutomationProject", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "projectDescription", + "target": "ProjectDescription" + }, + { + "source": "projectName", + "target": "ProjectName" + }, + { + "source": "projectType", + "target": "ProjectType" + } + ], + "operation": "CreateDataAutomationProject", + "phase": "create", + "service": "bedrock-data-automation" + }, + { + "cfn_type": "AWS::Bedrock::DataAutomationProject", + "mappings": [], + "operation": "DeleteDataAutomationProject", + "phase": "delete", + "service": "bedrock-data-automation" + }, + { + "cfn_type": "AWS::Bedrock::DataSource", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "dataDeletionPolicy", + "target": "DataDeletionPolicy" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "knowledgeBaseId", + "target": "KnowledgeBaseId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateDataSource", + "phase": "create", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::DataSource", + "mappings": [ + { + "source": "knowledgeBaseId", + "target": "KnowledgeBaseId" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::EnforcedGuardrailConfiguration", + "mappings": [], + "operation": "DeleteEnforcedGuardrailConfiguration", + "phase": "delete", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::FlowAlias", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateFlowAlias", + "phase": "create", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::FlowAlias", + "mappings": [], + "operation": "DeleteFlowAlias", + "phase": "delete", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::Guardrail", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "blockedInputMessaging", + "target": "BlockedInputMessaging" + }, + { + "source": "blockedOutputsMessaging", + "target": "BlockedOutputsMessaging" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateGuardrail", + "phase": "create", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::Guardrail", + "mappings": [], + "operation": "DeleteGuardrail", + "phase": "delete", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::GuardrailVersion", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "guardrailIdentifier", + "target": "GuardrailIdentifier" + } + ], + "operation": "CreateGuardrailVersion", + "phase": "create", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::KnowledgeBase", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateKnowledgeBase", + "phase": "create", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::KnowledgeBase", + "mappings": [], + "operation": "DeleteKnowledgeBase", + "phase": "delete", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::Prompt", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "customerEncryptionKeyArn", + "target": "CustomerEncryptionKeyArn" + }, + { + "source": "defaultVariant", + "target": "DefaultVariant" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreatePrompt", + "phase": "create", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::Prompt", + "mappings": [], + "operation": "DeletePrompt", + "phase": "delete", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::PromptVersion", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + } + ], + "operation": "CreatePromptVersion", + "phase": "create", + "service": "bedrock-agent" + }, + { + "cfn_type": "AWS::Bedrock::ResourcePolicy", + "mappings": [ + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::ResourcePolicy", + "mappings": [ + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "bedrock" + }, + { + "cfn_type": "AWS::Bedrock::Session", + "mappings": [ + { + "source": "encryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateSession", + "phase": "create", + "service": "bedrock-agent-runtime" + }, + { + "cfn_type": "AWS::Bedrock::Session", + "mappings": [], + "operation": "DeleteSession", + "phase": "delete", + "service": "bedrock-agent-runtime" + }, + { + "cfn_type": "AWS::BedrockAgentCore::ApiKeyCredentialProvider", + "mappings": [ + { + "source": "apiKey", + "target": "ApiKey" + }, + { + "source": "apiKeySecretSource", + "target": "ApiKeySecretSource" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateApiKeyCredentialProvider", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::ApiKeyCredentialProvider", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteApiKeyCredentialProvider", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::BrowserProfile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateBrowserProfile", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::BrowserProfile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteBrowserProfile", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::CapacityProvider", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCapacityProvider", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::CapacityProvider", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteCapacityProvider", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::CodeInterpreterCustom", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateCodeInterpreter", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::ConfigurationBundle", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "branchName", + "target": "BranchName" + }, + { + "source": "bundleName", + "target": "BundleName" + }, + { + "source": "commitMessage", + "target": "CommitMessage" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConfigurationBundle", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::ConfigurationBundle", + "mappings": [], + "operation": "DeleteConfigurationBundle", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Dataset", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "datasetName", + "target": "DatasetName" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "schemaType", + "target": "SchemaType" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDataset", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Dataset", + "mappings": [], + "operation": "DeleteDataset", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Evaluator", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "evaluatorName", + "target": "EvaluatorName" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "level", + "target": "Level" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateEvaluator", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Evaluator", + "mappings": [], + "operation": "DeleteEvaluator", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Gateway", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "authorizerType", + "target": "AuthorizerType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "exceptionLevel", + "target": "ExceptionLevel" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateGateway", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Gateway", + "mappings": [], + "operation": "DeleteGateway", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::GatewayRateLimit", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "dimensionKeys", + "target": "DimensionKeys" + }, + { + "source": "gatewayIdentifier", + "target": "GatewayIdentifier" + }, + { + "source": "rateLimitId", + "target": "RateLimitId" + } + ], + "operation": "CreateGatewayRateLimit", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::GatewayRateLimit", + "mappings": [ + { + "source": "gatewayIdentifier", + "target": "GatewayIdentifier" + }, + { + "source": "rateLimitId", + "target": "RateLimitId" + } + ], + "operation": "DeleteGatewayRateLimit", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::GatewayRule", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "gatewayIdentifier", + "target": "GatewayIdentifier" + }, + { + "source": "priority", + "target": "Priority" + } + ], + "operation": "CreateGatewayRule", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::GatewayRule", + "mappings": [ + { + "source": "gatewayIdentifier", + "target": "GatewayIdentifier" + } + ], + "operation": "DeleteGatewayRule", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::GatewayTarget", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "gatewayIdentifier", + "target": "GatewayIdentifier" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateGatewayTarget", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::GatewayTarget", + "mappings": [ + { + "source": "gatewayIdentifier", + "target": "GatewayIdentifier" + } + ], + "operation": "DeleteGatewayTarget", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Harness", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "allowedTools", + "target": "AllowedTools" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "harnessName", + "target": "HarnessName" + }, + { + "source": "maxIterations", + "target": "MaxIterations" + }, + { + "source": "maxTokens", + "target": "MaxTokens" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "timeoutSeconds", + "target": "TimeoutSeconds" + } + ], + "operation": "CreateHarness", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Harness", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteHarness", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::HarnessEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "endpointName", + "target": "EndpointName" + }, + { + "source": "harnessId", + "target": "HarnessId" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetVersion", + "target": "TargetVersion" + } + ], + "operation": "CreateHarnessEndpoint", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::HarnessEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "endpointName", + "target": "EndpointName" + }, + { + "source": "harnessId", + "target": "HarnessId" + } + ], + "operation": "DeleteHarnessEndpoint", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Memory", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "encryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "eventExpiryDuration", + "target": "EventExpiryDuration" + }, + { + "source": "memoryExecutionRoleArn", + "target": "MemoryExecutionRoleArn" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateMemory", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Memory", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteMemory", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::OAuth2CredentialProvider", + "mappings": [ + { + "source": "credentialProviderVendor", + "target": "CredentialProviderVendor" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateOauth2CredentialProvider", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::OAuth2CredentialProvider", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteOauth2CredentialProvider", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::OnlineEvaluationConfig", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "evaluationExecutionRoleArn", + "target": "EvaluationExecutionRoleArn" + }, + { + "source": "onlineEvaluationConfigName", + "target": "OnlineEvaluationConfigName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateOnlineEvaluationConfig", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::OnlineEvaluationConfig", + "mappings": [], + "operation": "DeleteOnlineEvaluationConfig", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PaymentConnector", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "paymentManagerId", + "target": "PaymentManagerId" + } + ], + "operation": "CreatePaymentConnector", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PaymentConnector", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "paymentManagerId", + "target": "PaymentManagerId" + } + ], + "operation": "DeletePaymentConnector", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PaymentCredentialProvider", + "mappings": [ + { + "source": "credentialProviderVendor", + "target": "CredentialProviderVendor" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePaymentCredentialProvider", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PaymentCredentialProvider", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeletePaymentCredentialProvider", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PaymentManager", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "authorizerType", + "target": "AuthorizerType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePaymentManager", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PaymentManager", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeletePaymentManager", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Policy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "enforcementMode", + "target": "EnforcementMode" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policyEngineId", + "target": "PolicyEngineId" + }, + { + "source": "validationMode", + "target": "ValidationMode" + } + ], + "operation": "CreatePolicy", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Policy", + "mappings": [ + { + "source": "policyEngineId", + "target": "PolicyEngineId" + } + ], + "operation": "DeletePolicy", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PolicyEngine", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "encryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePolicyEngine", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::PolicyEngine", + "mappings": [], + "operation": "DeletePolicyEngine", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::ResourcePolicy", + "mappings": [ + { + "source": "policy", + "target": "Policy" + }, + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::ResourcePolicy", + "mappings": [ + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Runtime", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "agentRuntimeName", + "target": "AgentRuntimeName" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateAgentRuntime", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::Runtime", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteAgentRuntime", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::RuntimeEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "agentRuntimeId", + "target": "AgentRuntimeId" + }, + { + "source": "agentRuntimeVersion", + "target": "AgentRuntimeVersion" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateAgentRuntimeEndpoint", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::RuntimeEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "agentRuntimeId", + "target": "AgentRuntimeId" + } + ], + "operation": "DeleteAgentRuntimeEndpoint", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::WorkloadIdentity", + "mappings": [ + { + "source": "allowedResourceOauth2ReturnUrls", + "target": "AllowedResourceOauth2ReturnUrls" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateWorkloadIdentity", + "phase": "create", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::BedrockAgentCore::WorkloadIdentity", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteWorkloadIdentity", + "phase": "delete", + "service": "bedrock-agentcore-control" + }, + { + "cfn_type": "AWS::Billing::BillingView", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "sourceViews", + "target": "SourceViews" + } + ], + "operation": "CreateBillingView", + "phase": "create", + "service": "billing" + }, + { + "cfn_type": "AWS::Billing::BillingView", + "mappings": [], + "operation": "DeleteBillingView", + "phase": "delete", + "service": "billing" + }, + { + "cfn_type": "AWS::BillingConductor::BillingGroup", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PrimaryAccountId", + "target": "PrimaryAccountId" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateBillingGroup", + "phase": "create", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::BillingGroup", + "mappings": [], + "operation": "DeleteBillingGroup", + "phase": "delete", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::CustomLineItem", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AccountId", + "target": "AccountId" + }, + { + "source": "BillingGroupArn", + "target": "BillingGroupArn" + }, + { + "source": "ComputationRule", + "target": "ComputationRule" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCustomLineItem", + "phase": "create", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::CustomLineItem", + "mappings": [], + "operation": "DeleteCustomLineItem", + "phase": "delete", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::PricingPlan", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PricingRuleArns", + "target": "PricingRuleArns" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePricingPlan", + "phase": "create", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::PricingPlan", + "mappings": [], + "operation": "DeletePricingPlan", + "phase": "delete", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::PricingRule", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "BillingEntity", + "target": "BillingEntity" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "ModifierPercentage", + "target": "ModifierPercentage" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Operation", + "target": "Operation" + }, + { + "source": "Scope", + "target": "Scope" + }, + { + "source": "Service", + "target": "Service" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Type", + "target": "Type" + }, + { + "source": "UsageType", + "target": "UsageType" + } + ], + "operation": "CreatePricingRule", + "phase": "create", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::BillingConductor::PricingRule", + "mappings": [], + "operation": "DeletePricingRule", + "phase": "delete", + "service": "billingconductor" + }, + { + "cfn_type": "AWS::Braket::SpendingLimit", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "deviceArn", + "target": "DeviceArn" + }, + { + "source": "spendingLimit", + "target": "SpendingLimit" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateSpendingLimit", + "phase": "create", + "service": "braket" + }, + { + "cfn_type": "AWS::Braket::SpendingLimit", + "mappings": [], + "operation": "DeleteSpendingLimit", + "phase": "delete", + "service": "braket" + }, + { + "cfn_type": "AWS::Budgets::BudgetsAction", + "mappings": [ + { + "source": "ActionType", + "target": "ActionType" + }, + { + "source": "ApprovalModel", + "target": "ApprovalModel" + }, + { + "source": "BudgetName", + "target": "BudgetName" + }, + { + "source": "ExecutionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "NotificationType", + "target": "NotificationType" + } + ], + "operation": "CreateBudgetAction", + "phase": "create", + "service": "budgets" + }, + { + "cfn_type": "AWS::CE::AnomalyMonitor", + "mappings": [], + "operation": "DeleteAnomalyMonitor", + "phase": "delete", + "service": "ce" + }, + { + "cfn_type": "AWS::CE::AnomalySubscription", + "mappings": [], + "operation": "DeleteAnomalySubscription", + "phase": "delete", + "service": "ce" + }, + { + "cfn_type": "AWS::CE::CostCategory", + "mappings": [ + { + "source": "DefaultValue", + "target": "DefaultValue" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RuleVersion", + "target": "RuleVersion" + } + ], + "operation": "CreateCostCategoryDefinition", + "phase": "create", + "service": "ce" + }, + { + "cfn_type": "AWS::CUR::ReportDefinition", + "mappings": [ + { + "source": "ReportName", + "target": "ReportName" + } + ], + "operation": "DeleteReportDefinition", + "phase": "delete", + "service": "cur" + }, + { + "cfn_type": "AWS::Cases::CaseRule", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainId", + "target": "DomainId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateCaseRule", + "phase": "create", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::CaseRule", + "mappings": [ + { + "source": "domainId", + "target": "DomainId" + } + ], + "operation": "DeleteCaseRule", + "phase": "delete", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Domain", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Domain", + "mappings": [], + "operation": "DeleteDomain", + "phase": "delete", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Field", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainId", + "target": "DomainId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateField", + "phase": "create", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Field", + "mappings": [ + { + "source": "domainId", + "target": "DomainId" + } + ], + "operation": "DeleteField", + "phase": "delete", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Layout", + "mappings": [ + { + "source": "domainId", + "target": "DomainId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateLayout", + "phase": "create", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Layout", + "mappings": [ + { + "source": "domainId", + "target": "DomainId" + } + ], + "operation": "DeleteLayout", + "phase": "delete", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Template", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainId", + "target": "DomainId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "CreateTemplate", + "phase": "create", + "service": "connectcases" + }, + { + "cfn_type": "AWS::Cases::Template", + "mappings": [ + { + "source": "domainId", + "target": "DomainId" + } + ], + "operation": "DeleteTemplate", + "phase": "delete", + "service": "connectcases" + }, + { + "cfn_type": "AWS::CertificateManager::AcmeDomainValidation", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcmeEndpointArn", + "target": "AcmeEndpointArn" + }, + { + "source": "DomainName", + "target": "DomainName" + } + ], + "operation": "CreateAcmeDomainValidation", + "phase": "create", + "service": "acm" + }, + { + "cfn_type": "AWS::CertificateManager::AcmeDomainValidation", + "mappings": [], + "operation": "DeleteAcmeDomainValidation", + "phase": "delete", + "service": "acm" + }, + { + "cfn_type": "AWS::CertificateManager::AcmeEndpoint", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AuthorizationBehavior", + "target": "AuthorizationBehavior" + }, + { + "source": "Contact", + "target": "Contact" + } + ], + "operation": "CreateAcmeEndpoint", + "phase": "create", + "service": "acm" + }, + { + "cfn_type": "AWS::CertificateManager::AcmeEndpoint", + "mappings": [], + "operation": "DeleteAcmeEndpoint", + "phase": "delete", + "service": "acm" + }, + { + "cfn_type": "AWS::CertificateManager::AcmeExternalAccountBinding", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcmeEndpointArn", + "target": "AcmeEndpointArn" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateAcmeExternalAccountBinding", + "phase": "create", + "service": "acm" + }, + { + "cfn_type": "AWS::CertificateManager::AcmeExternalAccountBinding", + "mappings": [], + "operation": "DeleteAcmeExternalAccountBinding", + "phase": "delete", + "service": "acm" + }, + { + "cfn_type": "AWS::CertificateManager::Certificate", + "mappings": [], + "operation": "DeleteCertificate", + "phase": "delete", + "service": "acm" + }, + { + "cfn_type": "AWS::Chatbot::CustomAction", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ActionName", + "target": "ActionName" + }, + { + "source": "AliasName", + "target": "AliasName" + } + ], + "operation": "CreateCustomAction", + "phase": "create", + "service": "chatbot" + }, + { + "cfn_type": "AWS::Chatbot::CustomAction", + "mappings": [], + "operation": "DeleteCustomAction", + "phase": "delete", + "service": "chatbot" + }, + { + "cfn_type": "AWS::Chatbot::MicrosoftTeamsChannelConfiguration", + "mappings": [ + { + "source": "ConfigurationName", + "target": "ConfigurationName" + }, + { + "source": "IamRoleArn", + "target": "IamRoleArn" + }, + { + "source": "LoggingLevel", + "target": "LoggingLevel" + }, + { + "source": "SnsTopicArns", + "target": "SnsTopicArns" + }, + { + "source": "TeamId", + "target": "TeamId" + } + ], + "operation": "CreateMicrosoftTeamsChannelConfiguration", + "phase": "create", + "service": "chatbot" + }, + { + "cfn_type": "AWS::Chatbot::MicrosoftTeamsChannelConfiguration", + "mappings": [], + "operation": "DeleteMicrosoftTeamsChannelConfiguration", + "phase": "delete", + "service": "chatbot" + }, + { + "cfn_type": "AWS::Chatbot::SlackChannelConfiguration", + "mappings": [ + { + "source": "ConfigurationName", + "target": "ConfigurationName" + }, + { + "source": "IamRoleArn", + "target": "IamRoleArn" + }, + { + "source": "LoggingLevel", + "target": "LoggingLevel" + }, + { + "source": "SlackChannelId", + "target": "SlackChannelId" + }, + { + "source": "SnsTopicArns", + "target": "SnsTopicArns" + } + ], + "operation": "CreateSlackChannelConfiguration", + "phase": "create", + "service": "chatbot" + }, + { + "cfn_type": "AWS::Chatbot::SlackChannelConfiguration", + "mappings": [], + "operation": "DeleteSlackChannelConfiguration", + "phase": "delete", + "service": "chatbot" + }, + { + "cfn_type": "AWS::Chime::AppInstance", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Metadata", + "target": "Metadata" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAppInstance", + "phase": "create", + "service": "chime-sdk-identity" + }, + { + "cfn_type": "AWS::Chime::AppInstance", + "mappings": [], + "operation": "DeleteAppInstance", + "phase": "delete", + "service": "chime-sdk-identity" + }, + { + "cfn_type": "AWS::Chime::AppInstanceBot", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "AppInstanceArn", + "target": "AppInstanceArn" + }, + { + "source": "Metadata", + "target": "Metadata" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAppInstanceBot", + "phase": "create", + "service": "chime-sdk-identity" + }, + { + "cfn_type": "AWS::Chime::AppInstanceBot", + "mappings": [], + "operation": "DeleteAppInstanceBot", + "phase": "delete", + "service": "chime-sdk-identity" + }, + { + "cfn_type": "AWS::Chime::AppInstanceUser", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "AppInstanceArn", + "target": "AppInstanceArn" + }, + { + "source": "AppInstanceUserId", + "target": "AppInstanceUserId" + }, + { + "source": "Metadata", + "target": "Metadata" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAppInstanceUser", + "phase": "create", + "service": "chime-sdk-identity" + }, + { + "cfn_type": "AWS::Chime::AppInstanceUser", + "mappings": [], + "operation": "DeleteAppInstanceUser", + "phase": "delete", + "service": "chime-sdk-identity" + }, + { + "cfn_type": "AWS::Chime::ChannelFlow", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "AppInstanceArn", + "target": "AppInstanceArn" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateChannelFlow", + "phase": "create", + "service": "chime-sdk-messaging" + }, + { + "cfn_type": "AWS::Chime::ChannelFlow", + "mappings": [], + "operation": "DeleteChannelFlow", + "phase": "delete", + "service": "chime-sdk-messaging" + }, + { + "cfn_type": "AWS::CleanRooms::AnalysisTemplate", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "format", + "target": "Format" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAnalysisTemplate", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::AnalysisTemplate", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeleteAnalysisTemplate", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::Collaboration", + "mappings": [ + { + "source": "allowedResultRegions", + "target": "AllowedResultRegions" + }, + { + "source": "analyticsEngine", + "target": "AnalyticsEngine" + }, + { + "source": "creatorDisplayName", + "target": "CreatorDisplayName" + }, + { + "source": "creatorMemberAbilities", + "target": "CreatorMemberAbilities" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "isMetricsEnabled", + "target": "IsMetricsEnabled" + }, + { + "source": "jobLogStatus", + "target": "JobLogStatus" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "queryLogStatus", + "target": "QueryLogStatus" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCollaboration", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::Collaboration", + "mappings": [], + "operation": "DeleteCollaboration", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::ConfiguredTable", + "mappings": [ + { + "source": "allowedColumns", + "target": "AllowedColumns" + }, + { + "source": "analysisMethod", + "target": "AnalysisMethod" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "selectedAnalysisMethods", + "target": "SelectedAnalysisMethods" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConfiguredTable", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::ConfiguredTable", + "mappings": [], + "operation": "DeleteConfiguredTable", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::ConfiguredTableAssociation", + "mappings": [ + { + "source": "configuredTableIdentifier", + "target": "ConfiguredTableIdentifier" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConfiguredTableAssociation", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::ConfiguredTableAssociation", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeleteConfiguredTableAssociation", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::IdMappingTable", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateIdMappingTable", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::IdMappingTable", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeleteIdMappingTable", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::IdNamespaceAssociation", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateIdNamespaceAssociation", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::IdNamespaceAssociation", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeleteIdNamespaceAssociation", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::IntermediateTable", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateIntermediateTable", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::IntermediateTable", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeleteIntermediateTable", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::Membership", + "mappings": [ + { + "source": "collaborationIdentifier", + "target": "CollaborationIdentifier" + }, + { + "source": "isMetricsEnabled", + "target": "IsMetricsEnabled" + }, + { + "source": "jobLogStatus", + "target": "JobLogStatus" + }, + { + "source": "queryLogStatus", + "target": "QueryLogStatus" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateMembership", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::Membership", + "mappings": [], + "operation": "DeleteMembership", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::PrivacyBudgetTemplate", + "mappings": [ + { + "source": "autoRefresh", + "target": "AutoRefresh" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "privacyBudgetType", + "target": "PrivacyBudgetType" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePrivacyBudgetTemplate", + "phase": "create", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRooms::PrivacyBudgetTemplate", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeletePrivacyBudgetTemplate", + "phase": "delete", + "service": "cleanrooms" + }, + { + "cfn_type": "AWS::CleanRoomsML::ConfiguredModelAlgorithm", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConfiguredModelAlgorithm", + "phase": "create", + "service": "cleanroomsml" + }, + { + "cfn_type": "AWS::CleanRoomsML::ConfiguredModelAlgorithm", + "mappings": [], + "operation": "DeleteConfiguredModelAlgorithm", + "phase": "delete", + "service": "cleanroomsml" + }, + { + "cfn_type": "AWS::CleanRoomsML::ConfiguredModelAlgorithmAssociation", + "mappings": [ + { + "source": "configuredModelAlgorithmArn", + "target": "ConfiguredModelAlgorithmArn" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConfiguredModelAlgorithmAssociation", + "phase": "create", + "service": "cleanroomsml" + }, + { + "cfn_type": "AWS::CleanRoomsML::ConfiguredModelAlgorithmAssociation", + "mappings": [ + { + "source": "membershipIdentifier", + "target": "MembershipIdentifier" + } + ], + "operation": "DeleteConfiguredModelAlgorithmAssociation", + "phase": "delete", + "service": "cleanroomsml" + }, + { + "cfn_type": "AWS::CleanRoomsML::TrainingDataset", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateTrainingDataset", + "phase": "create", + "service": "cleanroomsml" + }, + { + "cfn_type": "AWS::CleanRoomsML::TrainingDataset", + "mappings": [], + "operation": "DeleteTrainingDataset", + "phase": "delete", + "service": "cleanroomsml" + }, + { + "cfn_type": "AWS::CloudFront::AnycastIpList", + "mappings": [ + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "IpCount", + "target": "IpCount" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAnycastIpList", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::AnycastIpList", + "mappings": [], + "operation": "DeleteAnycastIpList", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::CachePolicy", + "mappings": [], + "operation": "DeleteCachePolicy", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::CloudFrontOriginAccessIdentity", + "mappings": [], + "operation": "DeleteCloudFrontOriginAccessIdentity", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::ConnectionFunction", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConnectionFunction", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::ConnectionFunction", + "mappings": [], + "operation": "DeleteConnectionFunction", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::ConnectionGroup", + "mappings": [ + { + "source": "AnycastIpListId", + "target": "AnycastIpListId" + }, + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "Ipv6Enabled", + "target": "Ipv6Enabled" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConnectionGroup", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::ConnectionGroup", + "mappings": [], + "operation": "DeleteConnectionGroup", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::ContinuousDeploymentPolicy", + "mappings": [], + "operation": "DeleteContinuousDeploymentPolicy", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::Distribution", + "mappings": [], + "operation": "DeleteDistribution", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::DistributionTenant", + "mappings": [ + { + "source": "ConnectionGroupId", + "target": "ConnectionGroupId" + }, + { + "source": "DistributionId", + "target": "DistributionId" + }, + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateDistributionTenant", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::DistributionTenant", + "mappings": [], + "operation": "DeleteDistributionTenant", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::Function", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateFunction", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::Function", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteFunction", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::KeyGroup", + "mappings": [], + "operation": "DeleteKeyGroup", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::KeyValueStore", + "mappings": [ + { + "source": "Comment", + "target": "Comment" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateKeyValueStore", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::KeyValueStore", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteKeyValueStore", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::MonitoringSubscription", + "mappings": [ + { + "source": "DistributionId", + "target": "DistributionId" + } + ], + "operation": "CreateMonitoringSubscription", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::MonitoringSubscription", + "mappings": [ + { + "source": "DistributionId", + "target": "DistributionId" + } + ], + "operation": "DeleteMonitoringSubscription", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::OriginAccessControl", + "mappings": [], + "operation": "DeleteOriginAccessControl", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::OriginRequestPolicy", + "mappings": [], + "operation": "DeleteOriginRequestPolicy", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::PublicKey", + "mappings": [], + "operation": "DeletePublicKey", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::RealtimeLogConfig", + "mappings": [ + { + "source": "Fields", + "target": "Fields" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SamplingRate", + "target": "SamplingRate" + } + ], + "operation": "CreateRealtimeLogConfig", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::RealtimeLogConfig", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteRealtimeLogConfig", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::ResponseHeadersPolicy", + "mappings": [], + "operation": "DeleteResponseHeadersPolicy", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::TrustStore", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "UseClientCertificateOCSPEndpoint", + "target": "UseClientCertificateOCSPEndpoint" + } + ], + "operation": "CreateTrustStore", + "phase": "create", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::TrustStore", + "mappings": [], + "operation": "DeleteTrustStore", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudFront::VpcOrigin", + "mappings": [], + "operation": "DeleteVpcOrigin", + "phase": "delete", + "service": "cloudfront" + }, + { + "cfn_type": "AWS::CloudHSM::Cluster", + "mappings": [ + { + "source": "HsmType", + "target": "HsmType" + }, + { + "source": "Mode", + "target": "Mode" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "cloudhsmv2" + }, + { + "cfn_type": "AWS::CloudHSM::Cluster", + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "cloudhsmv2" + }, + { + "cfn_type": "AWS::CloudTrail::Channel", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Source", + "target": "Source" + } + ], + "operation": "CreateChannel", + "phase": "create", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::Channel", + "mappings": [], + "operation": "DeleteChannel", + "phase": "delete", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::Dashboard", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "TerminationProtectionEnabled", + "target": "TerminationProtectionEnabled" + } + ], + "operation": "CreateDashboard", + "phase": "create", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::Dashboard", + "mappings": [], + "operation": "DeleteDashboard", + "phase": "delete", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::EventDataStore", + "mappings": [ + { + "source": "BillingMode", + "target": "BillingMode" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MultiRegionEnabled", + "target": "MultiRegionEnabled" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OrganizationEnabled", + "target": "OrganizationEnabled" + }, + { + "source": "RetentionPeriod", + "target": "RetentionPeriod" + }, + { + "source": "TerminationProtectionEnabled", + "target": "TerminationProtectionEnabled" + } + ], + "operation": "CreateEventDataStore", + "phase": "create", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::EventDataStore", + "mappings": [], + "operation": "DeleteEventDataStore", + "phase": "delete", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::ResourcePolicy", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + }, + { + "source": "ResourcePolicy", + "target": "ResourcePolicy" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::ResourcePolicy", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::Trail", + "mappings": [ + { + "source": "CloudWatchLogsLogGroupArn", + "target": "CloudWatchLogsLogGroupArn" + }, + { + "source": "CloudWatchLogsRoleArn", + "target": "CloudWatchLogsRoleArn" + }, + { + "source": "EnableLogFileValidation", + "target": "EnableLogFileValidation" + }, + { + "source": "IncludeGlobalServiceEvents", + "target": "IncludeGlobalServiceEvents" + }, + { + "source": "IsMultiRegionTrail", + "target": "IsMultiRegionTrail" + }, + { + "source": "IsOrganizationTrail", + "target": "IsOrganizationTrail" + }, + { + "source": "KmsKeyId", + "target": "KMSKeyId" + }, + { + "source": "Name", + "target": "TrailName" + }, + { + "source": "S3BucketName", + "target": "S3BucketName" + }, + { + "source": "S3KeyPrefix", + "target": "S3KeyPrefix" + }, + { + "source": "SnsTopicName", + "target": "SnsTopicName" + } + ], + "operation": "CreateTrail", + "phase": "create", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudTrail::Trail", + "mappings": [ + { + "source": "Name", + "target": "TrailName" + } + ], + "operation": "DeleteTrail", + "phase": "delete", + "service": "cloudtrail" + }, + { + "cfn_type": "AWS::CloudWatch::Alarm", + "mappings": [ + { + "source": "ActionsEnabled", + "target": "ActionsEnabled" + }, + { + "source": "AlarmActions", + "target": "AlarmActions" + }, + { + "source": "AlarmDescription", + "target": "AlarmDescription" + }, + { + "source": "AlarmName", + "target": "AlarmName" + }, + { + "source": "ComparisonOperator", + "target": "ComparisonOperator" + }, + { + "source": "DatapointsToAlarm", + "target": "DatapointsToAlarm" + }, + { + "source": "EvaluateLowSampleCountPercentile", + "target": "EvaluateLowSampleCountPercentile" + }, + { + "source": "EvaluationInterval", + "target": "EvaluationInterval" + }, + { + "source": "EvaluationPeriods", + "target": "EvaluationPeriods" + }, + { + "source": "ExtendedStatistic", + "target": "ExtendedStatistic" + }, + { + "source": "InsufficientDataActions", + "target": "InsufficientDataActions" + }, + { + "source": "MetricName", + "target": "MetricName" + }, + { + "source": "Namespace", + "target": "Namespace" + }, + { + "source": "OKActions", + "target": "OKActions" + }, + { + "source": "Period", + "target": "Period" + }, + { + "source": "Statistic", + "target": "Statistic" + }, + { + "source": "Threshold", + "target": "Threshold" + }, + { + "source": "ThresholdMetricId", + "target": "ThresholdMetricId" + }, + { + "source": "TreatMissingData", + "target": "TreatMissingData" + }, + { + "source": "Unit", + "target": "Unit" + } + ], + "operation": "PutMetricAlarm", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::Alarm", + "mappings": [], + "operation": "DeleteAlarms", + "phase": "delete", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::AlarmMuteRule", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "PutAlarmMuteRule", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::AlarmMuteRule", + "mappings": [], + "operation": "DeleteAlarmMuteRule", + "phase": "delete", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::CompositeAlarm", + "mappings": [ + { + "source": "ActionsEnabled", + "target": "ActionsEnabled" + }, + { + "source": "ActionsSuppressor", + "target": "ActionsSuppressor" + }, + { + "source": "ActionsSuppressorExtensionPeriod", + "target": "ActionsSuppressorExtensionPeriod" + }, + { + "source": "ActionsSuppressorWaitPeriod", + "target": "ActionsSuppressorWaitPeriod" + }, + { + "source": "AlarmActions", + "target": "AlarmActions" + }, + { + "source": "AlarmDescription", + "target": "AlarmDescription" + }, + { + "source": "AlarmName", + "target": "AlarmName" + }, + { + "source": "AlarmRule", + "target": "AlarmRule" + }, + { + "source": "InsufficientDataActions", + "target": "InsufficientDataActions" + }, + { + "source": "OKActions", + "target": "OKActions" + } + ], + "operation": "PutCompositeAlarm", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::Dashboard", + "mappings": [ + { + "source": "DashboardBody", + "target": "DashboardBody" + }, + { + "source": "DashboardName", + "target": "DashboardName" + } + ], + "operation": "PutDashboard", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::Dashboard", + "mappings": [], + "operation": "DeleteDashboards", + "phase": "delete", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::InsightRule", + "mappings": [ + { + "source": "ApplyOnTransformedLogs", + "target": "ApplyOnTransformedLogs" + }, + { + "source": "RuleName", + "target": "RuleName" + }, + { + "source": "RuleState", + "target": "RuleState" + } + ], + "operation": "PutInsightRule", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::InsightRule", + "mappings": [], + "operation": "DeleteInsightRules", + "phase": "delete", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::LogAlarm", + "mappings": [ + { + "source": "ActionLogLineCount", + "target": "ActionLogLineCount" + }, + { + "source": "ActionLogLineRoleArn", + "target": "ActionLogLineRoleArn" + }, + { + "source": "ActionsEnabled", + "target": "ActionsEnabled" + }, + { + "source": "AlarmActions", + "target": "AlarmActions" + }, + { + "source": "AlarmDescription", + "target": "AlarmDescription" + }, + { + "source": "AlarmName", + "target": "AlarmName" + }, + { + "source": "ComparisonOperator", + "target": "ComparisonOperator" + }, + { + "source": "InsufficientDataActions", + "target": "InsufficientDataActions" + }, + { + "source": "OKActions", + "target": "OKActions" + }, + { + "source": "QueryResultsToAlarm", + "target": "QueryResultsToAlarm" + }, + { + "source": "QueryResultsToEvaluate", + "target": "QueryResultsToEvaluate" + }, + { + "source": "Threshold", + "target": "Threshold" + }, + { + "source": "TreatMissingData", + "target": "TreatMissingData" + } + ], + "operation": "PutLogAlarm", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::MetricStream", + "mappings": [ + { + "source": "FirehoseArn", + "target": "FirehoseArn" + }, + { + "source": "IncludeLinkedAccountsMetrics", + "target": "IncludeLinkedAccountsMetrics" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OutputFormat", + "target": "OutputFormat" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "PutMetricStream", + "phase": "create", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CloudWatch::MetricStream", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteMetricStream", + "phase": "delete", + "service": "cloudwatch" + }, + { + "cfn_type": "AWS::CodeArtifact::Domain", + "mappings": [ + { + "source": "domain", + "target": "DomainName" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "codeartifact" + }, + { + "cfn_type": "AWS::CodeArtifact::Domain", + "mappings": [ + { + "source": "domain", + "target": "DomainName" + } + ], + "operation": "DeleteDomain", + "phase": "delete", + "service": "codeartifact" + }, + { + "cfn_type": "AWS::CodeArtifact::PackageGroup", + "mappings": [ + { + "source": "contactInfo", + "target": "ContactInfo" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "domain", + "target": "DomainName" + }, + { + "source": "domainOwner", + "target": "DomainOwner" + } + ], + "operation": "CreatePackageGroup", + "phase": "create", + "service": "codeartifact" + }, + { + "cfn_type": "AWS::CodeArtifact::PackageGroup", + "mappings": [ + { + "source": "domain", + "target": "DomainName" + }, + { + "source": "domainOwner", + "target": "DomainOwner" + } + ], + "operation": "DeletePackageGroup", + "phase": "delete", + "service": "codeartifact" + }, + { + "cfn_type": "AWS::CodeArtifact::Repository", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domain", + "target": "DomainName" + }, + { + "source": "repository", + "target": "RepositoryName" + } + ], + "operation": "CreateRepository", + "phase": "create", + "service": "codeartifact" + }, + { + "cfn_type": "AWS::CodeArtifact::Repository", + "mappings": [ + { + "source": "domain", + "target": "DomainName" + }, + { + "source": "repository", + "target": "RepositoryName" + } + ], + "operation": "DeleteRepository", + "phase": "delete", + "service": "codeartifact" + }, + { + "cfn_type": "AWS::CodeBuild::Fleet", + "mappings": [ + { + "source": "baseCapacity", + "target": "BaseCapacity" + }, + { + "source": "computeType", + "target": "ComputeType" + }, + { + "source": "environmentType", + "target": "EnvironmentType" + }, + { + "source": "fleetServiceRole", + "target": "FleetServiceRole" + }, + { + "source": "imageId", + "target": "ImageId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "overflowBehavior", + "target": "OverflowBehavior" + } + ], + "operation": "CreateFleet", + "phase": "create", + "service": "codebuild" + }, + { + "cfn_type": "AWS::CodeBuild::Fleet", + "mappings": [], + "operation": "DeleteFleet", + "phase": "delete", + "service": "codebuild" + }, + { + "cfn_type": "AWS::CodeConnections::Connection", + "mappings": [ + { + "source": "ConnectionName", + "target": "ConnectionName" + }, + { + "source": "HostArn", + "target": "HostArn" + }, + { + "source": "ProviderType", + "target": "ProviderType" + } + ], + "operation": "CreateConnection", + "phase": "create", + "service": "codeconnections" + }, + { + "cfn_type": "AWS::CodeConnections::Connection", + "mappings": [], + "operation": "DeleteConnection", + "phase": "delete", + "service": "codeconnections" + }, + { + "cfn_type": "AWS::CodeDeploy::Application", + "mappings": [ + { + "source": "applicationName", + "target": "ApplicationName" + }, + { + "source": "computePlatform", + "target": "ComputePlatform" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "codedeploy" + }, + { + "cfn_type": "AWS::CodeDeploy::Application", + "mappings": [ + { + "source": "applicationName", + "target": "ApplicationName" + } + ], + "operation": "DeleteApplication", + "phase": "delete", + "service": "codedeploy" + }, + { + "cfn_type": "AWS::CodeDeploy::DeploymentConfig", + "mappings": [ + { + "source": "computePlatform", + "target": "ComputePlatform" + }, + { + "source": "deploymentConfigName", + "target": "DeploymentConfigName" + } + ], + "operation": "CreateDeploymentConfig", + "phase": "create", + "service": "codedeploy" + }, + { + "cfn_type": "AWS::CodeDeploy::DeploymentConfig", + "mappings": [ + { + "source": "deploymentConfigName", + "target": "DeploymentConfigName" + } + ], + "operation": "DeleteDeploymentConfig", + "phase": "delete", + "service": "codedeploy" + }, + { + "cfn_type": "AWS::CodeDeploy::DeploymentGroup", + "mappings": [ + { + "source": "applicationName", + "target": "ApplicationName" + }, + { + "source": "autoScalingGroups", + "target": "AutoScalingGroups" + }, + { + "source": "deploymentConfigName", + "target": "DeploymentConfigName" + }, + { + "source": "deploymentGroupName", + "target": "DeploymentGroupName" + }, + { + "source": "outdatedInstancesStrategy", + "target": "OutdatedInstancesStrategy" + }, + { + "source": "serviceRoleArn", + "target": "ServiceRoleArn" + }, + { + "source": "terminationHookEnabled", + "target": "TerminationHookEnabled" + } + ], + "operation": "CreateDeploymentGroup", + "phase": "create", + "service": "codedeploy" + }, + { + "cfn_type": "AWS::CodeDeploy::DeploymentGroup", + "mappings": [ + { + "source": "applicationName", + "target": "ApplicationName" + }, + { + "source": "deploymentGroupName", + "target": "DeploymentGroupName" + } + ], + "operation": "DeleteDeploymentGroup", + "phase": "delete", + "service": "codedeploy" + }, + { + "cfn_type": "AWS::CodeGuruProfiler::ProfilingGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "computePlatform", + "target": "ComputePlatform" + }, + { + "source": "profilingGroupName", + "target": "ProfilingGroupName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateProfilingGroup", + "phase": "create", + "service": "codeguruprofiler" + }, + { + "cfn_type": "AWS::CodeGuruProfiler::ProfilingGroup", + "mappings": [ + { + "source": "profilingGroupName", + "target": "ProfilingGroupName" + } + ], + "operation": "DeleteProfilingGroup", + "phase": "delete", + "service": "codeguruprofiler" + }, + { + "cfn_type": "AWS::CodePipeline::CustomActionType", + "mappings": [ + { + "source": "category", + "target": "Category" + }, + { + "source": "provider", + "target": "Provider" + }, + { + "source": "version", + "target": "Version" + } + ], + "operation": "CreateCustomActionType", + "phase": "create", + "service": "codepipeline" + }, + { + "cfn_type": "AWS::CodePipeline::CustomActionType", + "mappings": [ + { + "source": "category", + "target": "Category" + }, + { + "source": "provider", + "target": "Provider" + }, + { + "source": "version", + "target": "Version" + } + ], + "operation": "DeleteCustomActionType", + "phase": "delete", + "service": "codepipeline" + }, + { + "cfn_type": "AWS::CodePipeline::Pipeline", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeletePipeline", + "phase": "delete", + "service": "codepipeline" + }, + { + "cfn_type": "AWS::CodePipeline::Webhook", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteWebhook", + "phase": "delete", + "service": "codepipeline" + }, + { + "cfn_type": "AWS::CodeStarConnections::Connection", + "mappings": [ + { + "source": "ConnectionName", + "target": "ConnectionName" + }, + { + "source": "HostArn", + "target": "HostArn" + }, + { + "source": "ProviderType", + "target": "ProviderType" + } + ], + "operation": "CreateConnection", + "phase": "create", + "service": "codestar-connections" + }, + { + "cfn_type": "AWS::CodeStarConnections::Connection", + "mappings": [], + "operation": "DeleteConnection", + "phase": "delete", + "service": "codestar-connections" + }, + { + "cfn_type": "AWS::CodeStarConnections::RepositoryLink", + "mappings": [ + { + "source": "ConnectionArn", + "target": "ConnectionArn" + }, + { + "source": "EncryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "OwnerId", + "target": "OwnerId" + }, + { + "source": "RepositoryName", + "target": "RepositoryName" + } + ], + "operation": "CreateRepositoryLink", + "phase": "create", + "service": "codestar-connections" + }, + { + "cfn_type": "AWS::CodeStarConnections::RepositoryLink", + "mappings": [], + "operation": "DeleteRepositoryLink", + "phase": "delete", + "service": "codestar-connections" + }, + { + "cfn_type": "AWS::CodeStarConnections::SyncConfiguration", + "mappings": [ + { + "source": "Branch", + "target": "Branch" + }, + { + "source": "ConfigFile", + "target": "ConfigFile" + }, + { + "source": "PublishDeploymentStatus", + "target": "PublishDeploymentStatus" + }, + { + "source": "RepositoryLinkId", + "target": "RepositoryLinkId" + }, + { + "source": "ResourceName", + "target": "ResourceName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "SyncType", + "target": "SyncType" + }, + { + "source": "TriggerResourceUpdateOn", + "target": "TriggerResourceUpdateOn" + } + ], + "operation": "CreateSyncConfiguration", + "phase": "create", + "service": "codestar-connections" + }, + { + "cfn_type": "AWS::CodeStarConnections::SyncConfiguration", + "mappings": [ + { + "source": "ResourceName", + "target": "ResourceName" + }, + { + "source": "SyncType", + "target": "SyncType" + } + ], + "operation": "DeleteSyncConfiguration", + "phase": "delete", + "service": "codestar-connections" + }, + { + "cfn_type": "AWS::CodeStarNotifications::NotificationRule", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "DetailType", + "target": "DetailType" + }, + { + "source": "EventTypeIds", + "target": "EventTypeIds" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Resource", + "target": "Resource" + }, + { + "source": "Status", + "target": "Status" + } + ], + "operation": "CreateNotificationRule", + "phase": "create", + "service": "codestar-notifications" + }, + { + "cfn_type": "AWS::CodeStarNotifications::NotificationRule", + "mappings": [], + "operation": "DeleteNotificationRule", + "phase": "delete", + "service": "codestar-notifications" + }, + { + "cfn_type": "AWS::Cognito::IdentityPool", + "mappings": [ + { + "source": "AllowClassicFlow", + "target": "AllowClassicFlow" + }, + { + "source": "AllowUnauthenticatedIdentities", + "target": "AllowUnauthenticatedIdentities" + }, + { + "source": "DeveloperProviderName", + "target": "DeveloperProviderName" + }, + { + "source": "IdentityPoolName", + "target": "IdentityPoolName" + }, + { + "source": "OpenIdConnectProviderARNs", + "target": "OpenIdConnectProviderARNs" + }, + { + "source": "SamlProviderARNs", + "target": "SamlProviderARNs" + } + ], + "operation": "CreateIdentityPool", + "phase": "create", + "service": "cognito-identity" + }, + { + "cfn_type": "AWS::Cognito::IdentityPool", + "mappings": [], + "operation": "DeleteIdentityPool", + "phase": "delete", + "service": "cognito-identity" + }, + { + "cfn_type": "AWS::Cognito::IdentityPoolPrincipalTag", + "mappings": [ + { + "source": "IdentityPoolId", + "target": "IdentityPoolId" + }, + { + "source": "IdentityProviderName", + "target": "IdentityProviderName" + }, + { + "source": "UseDefaults", + "target": "UseDefaults" + } + ], + "operation": "SetPrincipalTagAttributeMap", + "phase": "create", + "service": "cognito-identity" + }, + { + "cfn_type": "AWS::Cognito::LogDeliveryConfiguration", + "mappings": [ + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "SetLogDeliveryConfiguration", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::ManagedLoginBranding", + "mappings": [ + { + "source": "ClientId", + "target": "ClientId" + }, + { + "source": "UseCognitoProvidedValues", + "target": "UseCognitoProvidedValues" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateManagedLoginBranding", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::ManagedLoginBranding", + "mappings": [ + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteManagedLoginBranding", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::Terms", + "mappings": [ + { + "source": "ClientId", + "target": "ClientId" + }, + { + "source": "Enforcement", + "target": "Enforcement" + }, + { + "source": "TermsName", + "target": "TermsName" + }, + { + "source": "TermsSource", + "target": "TermsSource" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateTerms", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::Terms", + "mappings": [ + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteTerms", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPool", + "mappings": [ + { + "source": "AliasAttributes", + "target": "AliasAttributes" + }, + { + "source": "AutoVerifiedAttributes", + "target": "AutoVerifiedAttributes" + }, + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "EmailVerificationMessage", + "target": "EmailVerificationMessage" + }, + { + "source": "EmailVerificationSubject", + "target": "EmailVerificationSubject" + }, + { + "source": "MfaConfiguration", + "target": "MfaConfiguration" + }, + { + "source": "SmsAuthenticationMessage", + "target": "SmsAuthenticationMessage" + }, + { + "source": "SmsVerificationMessage", + "target": "SmsVerificationMessage" + }, + { + "source": "UserPoolTier", + "target": "UserPoolTier" + }, + { + "source": "UsernameAttributes", + "target": "UsernameAttributes" + } + ], + "operation": "CreateUserPool", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPool", + "mappings": [], + "operation": "DeleteUserPool", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolClient", + "mappings": [ + { + "source": "AccessTokenValidity", + "target": "AccessTokenValidity" + }, + { + "source": "AllowedOAuthFlows", + "target": "AllowedOAuthFlows" + }, + { + "source": "AllowedOAuthFlowsUserPoolClient", + "target": "AllowedOAuthFlowsUserPoolClient" + }, + { + "source": "AllowedOAuthScopes", + "target": "AllowedOAuthScopes" + }, + { + "source": "AuthSessionValidity", + "target": "AuthSessionValidity" + }, + { + "source": "CallbackURLs", + "target": "CallbackURLs" + }, + { + "source": "ClientName", + "target": "ClientName" + }, + { + "source": "DefaultRedirectURI", + "target": "DefaultRedirectURI" + }, + { + "source": "EnablePropagateAdditionalUserContextData", + "target": "EnablePropagateAdditionalUserContextData" + }, + { + "source": "EnableTokenRevocation", + "target": "EnableTokenRevocation" + }, + { + "source": "ExplicitAuthFlows", + "target": "ExplicitAuthFlows" + }, + { + "source": "GenerateSecret", + "target": "GenerateSecret" + }, + { + "source": "IdTokenValidity", + "target": "IdTokenValidity" + }, + { + "source": "LogoutURLs", + "target": "LogoutURLs" + }, + { + "source": "PreventUserExistenceErrors", + "target": "PreventUserExistenceErrors" + }, + { + "source": "ReadAttributes", + "target": "ReadAttributes" + }, + { + "source": "RefreshTokenValidity", + "target": "RefreshTokenValidity" + }, + { + "source": "SupportedIdentityProviders", + "target": "SupportedIdentityProviders" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + }, + { + "source": "WriteAttributes", + "target": "WriteAttributes" + } + ], + "operation": "CreateUserPoolClient", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolClient", + "mappings": [ + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteUserPoolClient", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolDomain", + "mappings": [ + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "ManagedLoginVersion", + "target": "ManagedLoginVersion" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateUserPoolDomain", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolDomain", + "mappings": [ + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteUserPoolDomain", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "Precedence", + "target": "Precedence" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateGroup", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolGroup", + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteGroup", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolIdentityProvider", + "mappings": [ + { + "source": "IdpIdentifiers", + "target": "IdpIdentifiers" + }, + { + "source": "ProviderName", + "target": "ProviderName" + }, + { + "source": "ProviderType", + "target": "ProviderType" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateIdentityProvider", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolIdentityProvider", + "mappings": [ + { + "source": "ProviderName", + "target": "ProviderName" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteIdentityProvider", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolReplica", + "mappings": [ + { + "source": "RegionName", + "target": "RegionName" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateUserPoolReplica", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolReplica", + "mappings": [ + { + "source": "RegionName", + "target": "RegionName" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteUserPoolReplica", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolResourceServer", + "mappings": [ + { + "source": "Identifier", + "target": "Identifier" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "CreateResourceServer", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolResourceServer", + "mappings": [ + { + "source": "Identifier", + "target": "Identifier" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "DeleteResourceServer", + "phase": "delete", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolRiskConfigurationAttachment", + "mappings": [ + { + "source": "ClientId", + "target": "ClientId" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "SetRiskConfiguration", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Cognito::UserPoolUICustomizationAttachment", + "mappings": [ + { + "source": "CSS", + "target": "CSS" + }, + { + "source": "ClientId", + "target": "ClientId" + }, + { + "source": "UserPoolId", + "target": "UserPoolId" + } + ], + "operation": "SetUICustomization", + "phase": "create", + "service": "cognito-idp" + }, + { + "cfn_type": "AWS::Comprehend::DocumentClassifier", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "DataAccessRoleArn", + "target": "DataAccessRoleArn" + }, + { + "source": "DocumentClassifierName", + "target": "DocumentClassifierName" + }, + { + "source": "LanguageCode", + "target": "LanguageCode" + }, + { + "source": "Mode", + "target": "Mode" + }, + { + "source": "ModelKmsKeyId", + "target": "ModelKmsKeyId" + }, + { + "source": "ModelPolicy", + "target": "ModelPolicy" + }, + { + "source": "VersionName", + "target": "VersionName" + }, + { + "source": "VolumeKmsKeyId", + "target": "VolumeKmsKeyId" + } + ], + "operation": "CreateDocumentClassifier", + "phase": "create", + "service": "comprehend" + }, + { + "cfn_type": "AWS::Comprehend::DocumentClassifier", + "mappings": [], + "operation": "DeleteDocumentClassifier", + "phase": "delete", + "service": "comprehend" + }, + { + "cfn_type": "AWS::Comprehend::Flywheel", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "ActiveModelArn", + "target": "ActiveModelArn" + }, + { + "source": "DataAccessRoleArn", + "target": "DataAccessRoleArn" + }, + { + "source": "DataLakeS3Uri", + "target": "DataLakeS3Uri" + }, + { + "source": "FlywheelName", + "target": "FlywheelName" + }, + { + "source": "ModelType", + "target": "ModelType" + } + ], + "operation": "CreateFlywheel", + "phase": "create", + "service": "comprehend" + }, + { + "cfn_type": "AWS::Comprehend::Flywheel", + "mappings": [], + "operation": "DeleteFlywheel", + "phase": "delete", + "service": "comprehend" + }, + { + "cfn_type": "AWS::Config::AggregationAuthorization", + "mappings": [ + { + "source": "AuthorizedAccountId", + "target": "AuthorizedAccountId" + }, + { + "source": "AuthorizedAwsRegion", + "target": "AuthorizedAwsRegion" + } + ], + "operation": "PutAggregationAuthorization", + "phase": "create", + "service": "config" + }, + { + "cfn_type": "AWS::Config::AggregationAuthorization", + "mappings": [ + { + "source": "AuthorizedAccountId", + "target": "AuthorizedAccountId" + }, + { + "source": "AuthorizedAwsRegion", + "target": "AuthorizedAwsRegion" + } + ], + "operation": "DeleteAggregationAuthorization", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::ConfigRule", + "mappings": [ + { + "source": "ConfigRuleName", + "target": "ConfigRuleName" + } + ], + "operation": "DeleteConfigRule", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::ConfigurationAggregator", + "mappings": [ + { + "source": "ConfigurationAggregatorName", + "target": "ConfigurationAggregatorName" + } + ], + "operation": "PutConfigurationAggregator", + "phase": "create", + "service": "config" + }, + { + "cfn_type": "AWS::Config::ConfigurationAggregator", + "mappings": [ + { + "source": "ConfigurationAggregatorName", + "target": "ConfigurationAggregatorName" + } + ], + "operation": "DeleteConfigurationAggregator", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::ConformancePack", + "mappings": [ + { + "source": "ConformancePackName", + "target": "ConformancePackName" + }, + { + "source": "DeliveryS3Bucket", + "target": "DeliveryS3Bucket" + }, + { + "source": "DeliveryS3KeyPrefix", + "target": "DeliveryS3KeyPrefix" + }, + { + "source": "TemplateBody", + "target": "TemplateBody" + }, + { + "source": "TemplateS3Uri", + "target": "TemplateS3Uri" + } + ], + "operation": "PutConformancePack", + "phase": "create", + "service": "config" + }, + { + "cfn_type": "AWS::Config::ConformancePack", + "mappings": [ + { + "source": "ConformancePackName", + "target": "ConformancePackName" + } + ], + "operation": "DeleteConformancePack", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::Connector", + "mappings": [], + "operation": "DeleteConnector", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::OrganizationConformancePack", + "mappings": [ + { + "source": "DeliveryS3Bucket", + "target": "DeliveryS3Bucket" + }, + { + "source": "DeliveryS3KeyPrefix", + "target": "DeliveryS3KeyPrefix" + }, + { + "source": "ExcludedAccounts", + "target": "ExcludedAccounts" + }, + { + "source": "OrganizationConformancePackName", + "target": "OrganizationConformancePackName" + }, + { + "source": "TemplateBody", + "target": "TemplateBody" + }, + { + "source": "TemplateS3Uri", + "target": "TemplateS3Uri" + } + ], + "operation": "PutOrganizationConformancePack", + "phase": "create", + "service": "config" + }, + { + "cfn_type": "AWS::Config::OrganizationConformancePack", + "mappings": [ + { + "source": "OrganizationConformancePackName", + "target": "OrganizationConformancePackName" + } + ], + "operation": "DeleteOrganizationConformancePack", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::RemediationConfiguration", + "mappings": [ + { + "source": "ConfigRuleName", + "target": "ConfigRuleName" + }, + { + "source": "ResourceType", + "target": "ResourceType" + } + ], + "operation": "DeleteRemediationConfiguration", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Config::StoredQuery", + "mappings": [ + { + "source": "QueryName", + "target": "QueryName" + } + ], + "operation": "DeleteStoredQuery", + "phase": "delete", + "service": "config" + }, + { + "cfn_type": "AWS::Connect::AgentStatus", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayOrder", + "target": "DisplayOrder" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "State", + "target": "State" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateAgentStatus", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ApprovedOrigin", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "Origin", + "target": "Origin" + } + ], + "operation": "AssociateApprovedOrigin", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ApprovedOrigin", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "Origin", + "target": "Origin" + } + ], + "operation": "DisassociateApprovedOrigin", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlow", + "mappings": [ + { + "source": "Content", + "target": "Content" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateContactFlow", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlow", + "mappings": [], + "operation": "DeleteContactFlow", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowModule", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Content", + "target": "Content" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Settings", + "target": "Settings" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateContactFlowModule", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowModule", + "mappings": [], + "operation": "DeleteContactFlowModule", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowModuleAlias", + "mappings": [ + { + "source": "ContactFlowModuleId", + "target": "ContactFlowModuleId" + }, + { + "source": "ContactFlowModuleVersion", + "target": "ContactFlowModuleVersion" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateContactFlowModuleAlias", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowModuleAlias", + "mappings": [ + { + "source": "ContactFlowModuleId", + "target": "ContactFlowModuleId" + } + ], + "operation": "DeleteContactFlowModuleAlias", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowModuleVersion", + "mappings": [ + { + "source": "ContactFlowModuleId", + "target": "ContactFlowModuleId" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateContactFlowModuleVersion", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowModuleVersion", + "mappings": [ + { + "source": "ContactFlowModuleId", + "target": "ContactFlowModuleId" + } + ], + "operation": "DeleteContactFlowModuleVersion", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowVersion", + "mappings": [ + { + "source": "ContactFlowId", + "target": "ContactFlowId" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateContactFlowVersion", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ContactFlowVersion", + "mappings": [ + { + "source": "ContactFlowId", + "target": "ContactFlowId" + } + ], + "operation": "DeleteContactFlowVersion", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::DataLakeAssociation", + "mappings": [ + { + "source": "DataSetId", + "target": "DataSetId" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "TargetAccountId", + "target": "TargetAccountId" + } + ], + "operation": "AssociateAnalyticsDataSet", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::DataLakeAssociation", + "mappings": [ + { + "source": "DataSetId", + "target": "DataSetId" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "TargetAccountId", + "target": "TargetAccountId" + } + ], + "operation": "DisassociateAnalyticsDataSet", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::DataTable", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Status", + "target": "Status" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TimeZone", + "target": "TimeZone" + }, + { + "source": "ValueLockLevel", + "target": "ValueLockLevel" + } + ], + "operation": "CreateDataTable", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::DataTable", + "mappings": [], + "operation": "DeleteDataTable", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::DataTableAttribute", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Primary", + "target": "Primary" + }, + { + "source": "ValueType", + "target": "ValueType" + } + ], + "operation": "CreateDataTableAttribute", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::DataTableAttribute", + "mappings": [], + "operation": "DeleteDataTableAttribute", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::EmailAddress", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "EmailAddress", + "target": "EmailAddress" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateEmailAddress", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::EmailAddress", + "mappings": [], + "operation": "DeleteEmailAddress", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::EvaluationForm", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Title", + "target": "Title" + } + ], + "operation": "CreateEvaluationForm", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::EvaluationForm", + "mappings": [], + "operation": "DeleteEvaluationForm", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::HoursOfOperation", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TimeZone", + "target": "TimeZone" + } + ], + "operation": "CreateHoursOfOperation", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::HoursOfOperation", + "mappings": [], + "operation": "DeleteHoursOfOperation", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Instance", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DirectoryId", + "target": "DirectoryId" + }, + { + "source": "IdentityManagementType", + "target": "IdentityManagementType" + }, + { + "source": "InstanceAlias", + "target": "InstanceAlias" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateInstance", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Instance", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [], + "operation": "DeleteInstance", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::InstanceStorageConfig", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ResourceType", + "target": "ResourceType" + } + ], + "operation": "AssociateInstanceStorageConfig", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::InstanceStorageConfig", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ResourceType", + "target": "ResourceType" + } + ], + "operation": "DisassociateInstanceStorageConfig", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::IntegrationAssociation", + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "IntegrationArn", + "target": "IntegrationArn" + }, + { + "source": "IntegrationType", + "target": "IntegrationType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateIntegrationAssociation", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::IntegrationAssociation", + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + } + ], + "operation": "DeleteIntegrationAssociation", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Notification", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Priority", + "target": "Priority" + }, + { + "source": "Recipients", + "target": "Recipients" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateNotification", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Notification", + "mappings": [], + "operation": "DeleteNotification", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::PhoneNumber", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "SourcePhoneNumberArn", + "target": "SourcePhoneNumberArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "ImportPhoneNumber", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::PhoneNumber", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [], + "operation": "ReleasePhoneNumber", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::PredefinedAttribute", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Purposes", + "target": "Purposes" + } + ], + "operation": "CreatePredefinedAttribute", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::PredefinedAttribute", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeletePredefinedAttribute", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Prompt", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "S3Uri", + "target": "S3Uri" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePrompt", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Prompt", + "mappings": [], + "operation": "DeletePrompt", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Queue", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "MaxContacts", + "target": "MaxContacts" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateQueue", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Queue", + "mappings": [], + "operation": "DeleteQueue", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::QuickConnect", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateQuickConnect", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::QuickConnect", + "mappings": [], + "operation": "DeleteQuickConnect", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::RoutingProfile", + "mappings": [ + { + "source": "AgentAvailabilityTimer", + "target": "AgentAvailabilityTimer" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRoutingProfile", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::RoutingProfile", + "mappings": [], + "operation": "DeleteRoutingProfile", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Rule", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Function", + "target": "Function" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PublishStatus", + "target": "PublishStatus" + } + ], + "operation": "CreateRule", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Rule", + "mappings": [], + "operation": "DeleteRule", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::SecurityKey", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "Key", + "target": "Key" + } + ], + "operation": "AssociateSecurityKey", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::SecurityKey", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + } + ], + "operation": "DisassociateSecurityKey", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::SecurityProfile", + "mappings": [ + { + "source": "AllowedAccessControlHierarchyGroupId", + "target": "AllowedAccessControlHierarchyGroupId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "HierarchyRestrictedResources", + "target": "HierarchyRestrictedResources" + }, + { + "source": "Permissions", + "target": "Permissions" + }, + { + "source": "SecurityProfileName", + "target": "SecurityProfileName" + }, + { + "source": "TagRestrictedResources", + "target": "TagRestrictedResources" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSecurityProfile", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::SecurityProfile", + "mappings": [], + "operation": "DeleteSecurityProfile", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::TaskTemplate", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Status", + "target": "Status" + } + ], + "operation": "CreateTaskTemplate", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::TaskTemplate", + "mappings": [], + "operation": "DeleteTaskTemplate", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::TestCase", + "mappings": [ + { + "source": "Content", + "target": "Content" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "InitializationData", + "target": "InitializationData" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Status", + "target": "Status" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateTestCase", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::TestCase", + "mappings": [], + "operation": "DeleteTestCase", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::TrafficDistributionGroup", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateTrafficDistributionGroup", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::TrafficDistributionGroup", + "mappings": [], + "operation": "DeleteTrafficDistributionGroup", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::User", + "mappings": [ + { + "source": "DirectoryUserId", + "target": "DirectoryUserId" + }, + { + "source": "Password", + "target": "Password" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Username", + "target": "Username" + } + ], + "operation": "CreateUser", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::User", + "mappings": [], + "operation": "DeleteUser", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::UserHierarchyGroup", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateUserHierarchyGroup", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::UserHierarchyGroup", + "mappings": [], + "operation": "DeleteUserHierarchyGroup", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::View", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateView", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::View", + "mappings": [], + "operation": "DeleteView", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ViewVersion", + "mappings": [ + { + "source": "VersionDescription", + "target": "VersionDescription" + }, + { + "source": "ViewContentSha256", + "target": "ViewContentSha256" + } + ], + "operation": "CreateViewVersion", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::ViewVersion", + "mappings": [], + "operation": "DeleteViewVersion", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Workspace", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Title", + "target": "Title" + } + ], + "operation": "CreateWorkspace", + "phase": "create", + "service": "connect" + }, + { + "cfn_type": "AWS::Connect::Workspace", + "mappings": [], + "operation": "DeleteWorkspace", + "phase": "delete", + "service": "connect" + }, + { + "cfn_type": "AWS::ConnectCampaigns::Campaign", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCampaign", + "phase": "create", + "service": "connectcampaigns" + }, + { + "cfn_type": "AWS::ConnectCampaigns::Campaign", + "mappings": [], + "operation": "DeleteCampaign", + "phase": "delete", + "service": "connectcampaigns" + }, + { + "cfn_type": "AWS::ConnectCampaignsV2::Campaign", + "mappings": [ + { + "source": "connectCampaignFlowArn", + "target": "ConnectCampaignFlowArn" + }, + { + "source": "connectInstanceId", + "target": "ConnectInstanceId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateCampaign", + "phase": "create", + "service": "connectcampaignsv2" + }, + { + "cfn_type": "AWS::ConnectCampaignsV2::Campaign", + "mappings": [], + "operation": "DeleteCampaign", + "phase": "delete", + "service": "connectcampaignsv2" + }, + { + "cfn_type": "AWS::ControlTower::EnabledBaseline", + "mappings": [ + { + "source": "baselineIdentifier", + "target": "BaselineIdentifier" + }, + { + "source": "baselineVersion", + "target": "BaselineVersion" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetIdentifier", + "target": "TargetIdentifier" + } + ], + "operation": "EnableBaseline", + "phase": "create", + "service": "controltower" + }, + { + "cfn_type": "AWS::ControlTower::EnabledControl", + "mappings": [ + { + "source": "controlIdentifier", + "target": "ControlIdentifier" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetIdentifier", + "target": "TargetIdentifier" + } + ], + "operation": "EnableControl", + "phase": "create", + "service": "controltower" + }, + { + "cfn_type": "AWS::ControlTower::LandingZone", + "mappings": [ + { + "source": "remediationTypes", + "target": "RemediationTypes" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "version", + "target": "Version" + } + ], + "operation": "CreateLandingZone", + "phase": "create", + "service": "controltower" + }, + { + "cfn_type": "AWS::ControlTower::LandingZone", + "mappings": [], + "operation": "DeleteLandingZone", + "phase": "delete", + "service": "controltower" + }, + { + "cfn_type": "AWS::CustomerProfiles::CalculatedAttributeDefinition", + "mappings": [ + { + "source": "CalculatedAttributeName", + "target": "CalculatedAttributeName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "Statistic", + "target": "Statistic" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "UseHistoricalData", + "target": "UseHistoricalData" + } + ], + "operation": "CreateCalculatedAttributeDefinition", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::CalculatedAttributeDefinition", + "mappings": [ + { + "source": "CalculatedAttributeName", + "target": "CalculatedAttributeName" + }, + { + "source": "DomainName", + "target": "DomainName" + } + ], + "operation": "DeleteCalculatedAttributeDefinition", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::Domain", + "mappings": [ + { + "source": "DeadLetterQueueUrl", + "target": "DeadLetterQueueUrl" + }, + { + "source": "DefaultEncryptionKey", + "target": "DefaultEncryptionKey" + }, + { + "source": "DefaultExpirationDays", + "target": "DefaultExpirationDays" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::Domain", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + } + ], + "operation": "DeleteDomain", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::DomainObjectType", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EncryptionKey", + "target": "EncryptionKey" + }, + { + "source": "ObjectTypeName", + "target": "ObjectTypeName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "PutDomainObjectType", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::DomainObjectType", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "ObjectTypeName", + "target": "ObjectTypeName" + } + ], + "operation": "DeleteDomainObjectType", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::EventStream", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EventStreamName", + "target": "EventStreamName" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Uri", + "target": "Uri" + } + ], + "operation": "CreateEventStream", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::EventStream", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EventStreamName", + "target": "EventStreamName" + } + ], + "operation": "DeleteEventStream", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::EventTrigger", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EventTriggerName", + "target": "EventTriggerName" + }, + { + "source": "ObjectTypeName", + "target": "ObjectTypeName" + }, + { + "source": "SegmentFilter", + "target": "SegmentFilter" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateEventTrigger", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::EventTrigger", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EventTriggerName", + "target": "EventTriggerName" + } + ], + "operation": "DeleteEventTrigger", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::Integration", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EventTriggerNames", + "target": "EventTriggerNames" + }, + { + "source": "ObjectTypeName", + "target": "ObjectTypeName" + }, + { + "source": "Scope", + "target": "Scope" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Uri", + "target": "Uri" + } + ], + "operation": "PutIntegration", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::Integration", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "Uri", + "target": "Uri" + } + ], + "operation": "DeleteIntegration", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::ObjectType", + "mappings": [ + { + "source": "AllowProfileCreation", + "target": "AllowProfileCreation" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "EncryptionKey", + "target": "EncryptionKey" + }, + { + "source": "ExpirationDays", + "target": "ExpirationDays" + }, + { + "source": "MaxProfileObjectCount", + "target": "MaxProfileObjectCount" + }, + { + "source": "ObjectTypeName", + "target": "ObjectTypeName" + }, + { + "source": "SourceLastUpdatedTimestampFormat", + "target": "SourceLastUpdatedTimestampFormat" + }, + { + "source": "SourcePriority", + "target": "SourcePriority" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TemplateId", + "target": "TemplateId" + } + ], + "operation": "PutProfileObjectType", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::ObjectType", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "ObjectTypeName", + "target": "ObjectTypeName" + } + ], + "operation": "DeleteProfileObjectType", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::Recommender", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "RecommenderName", + "target": "RecommenderName" + }, + { + "source": "RecommenderRecipeName", + "target": "RecommenderRecipeName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRecommender", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::Recommender", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "RecommenderName", + "target": "RecommenderName" + } + ], + "operation": "DeleteRecommender", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::SegmentDefinition", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "SegmentDefinitionName", + "target": "SegmentDefinitionName" + }, + { + "source": "SegmentSqlQuery", + "target": "SegmentSqlQuery" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSegmentDefinition", + "phase": "create", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::CustomerProfiles::SegmentDefinition", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "SegmentDefinitionName", + "target": "SegmentDefinitionName" + } + ], + "operation": "DeleteSegmentDefinition", + "phase": "delete", + "service": "customer-profiles" + }, + { + "cfn_type": "AWS::DMS::Certificate", + "mappings": [ + { + "source": "CertificateIdentifier", + "target": "CertificateIdentifier" + }, + { + "source": "CertificatePem", + "target": "CertificatePem" + } + ], + "operation": "ImportCertificate", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::Certificate", + "mappings": [], + "operation": "DeleteCertificate", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::DataMigration", + "mappings": [ + { + "source": "DataMigrationName", + "target": "DataMigrationName" + }, + { + "source": "DataMigrationType", + "target": "DataMigrationType" + }, + { + "source": "MigrationProjectIdentifier", + "target": "MigrationProjectIdentifier" + }, + { + "source": "ServiceAccessRoleArn", + "target": "ServiceAccessRoleArn" + } + ], + "operation": "CreateDataMigration", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::DataMigration", + "mappings": [ + { + "source": "DataMigrationIdentifier", + "target": "DataMigrationIdentifier" + } + ], + "operation": "DeleteDataMigration", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::DataProvider", + "mappings": [ + { + "source": "DataProviderName", + "target": "DataProviderName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Engine", + "target": "Engine" + } + ], + "operation": "CreateDataProvider", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::DataProvider", + "mappings": [ + { + "source": "DataProviderIdentifier", + "target": "DataProviderIdentifier" + } + ], + "operation": "DeleteDataProvider", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::Endpoint", + "mappings": [ + { + "source": "CertificateArn", + "target": "CertificateArn" + }, + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "EndpointIdentifier", + "target": "EndpointIdentifier" + }, + { + "source": "EndpointType", + "target": "EndpointType" + }, + { + "source": "EngineName", + "target": "EngineName" + }, + { + "source": "ExtraConnectionAttributes", + "target": "ExtraConnectionAttributes" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "Password", + "target": "Password" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "ResourceIdentifier", + "target": "ResourceIdentifier" + }, + { + "source": "ServerName", + "target": "ServerName" + }, + { + "source": "SslMode", + "target": "SslMode" + }, + { + "source": "Username", + "target": "Username" + } + ], + "operation": "CreateEndpoint", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::Endpoint", + "mappings": [], + "operation": "DeleteEndpoint", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::EventSubscription", + "mappings": [ + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "EventCategories", + "target": "EventCategories" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "SourceIds", + "target": "SourceIds" + }, + { + "source": "SourceType", + "target": "SourceType" + }, + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "CreateEventSubscription", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::EventSubscription", + "mappings": [ + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "DeleteEventSubscription", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::InstanceProfile", + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "InstanceProfileName", + "target": "InstanceProfileName" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "SubnetGroupIdentifier", + "target": "SubnetGroupIdentifier" + }, + { + "source": "VpcSecurityGroups", + "target": "VpcSecurityGroups" + } + ], + "operation": "CreateInstanceProfile", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::InstanceProfile", + "mappings": [ + { + "source": "InstanceProfileIdentifier", + "target": "InstanceProfileIdentifier" + } + ], + "operation": "DeleteInstanceProfile", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::MigrationProject", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "InstanceProfileIdentifier", + "target": "InstanceProfileIdentifier" + }, + { + "source": "MigrationProjectName", + "target": "MigrationProjectName" + }, + { + "source": "TransformationRules", + "target": "TransformationRules" + } + ], + "operation": "CreateMigrationProject", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::MigrationProject", + "mappings": [ + { + "source": "MigrationProjectIdentifier", + "target": "MigrationProjectIdentifier" + } + ], + "operation": "DeleteMigrationProject", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::ReplicationConfig", + "mappings": [ + { + "source": "ReplicationConfigIdentifier", + "target": "ReplicationConfigIdentifier" + }, + { + "source": "ReplicationSettings", + "target": "ReplicationSettings" + }, + { + "source": "ReplicationType", + "target": "ReplicationType" + }, + { + "source": "ResourceIdentifier", + "target": "ResourceIdentifier" + }, + { + "source": "SourceEndpointArn", + "target": "SourceEndpointArn" + }, + { + "source": "SupplementalSettings", + "target": "SupplementalSettings" + }, + { + "source": "TableMappings", + "target": "TableMappings" + }, + { + "source": "TargetEndpointArn", + "target": "TargetEndpointArn" + } + ], + "operation": "CreateReplicationConfig", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::ReplicationConfig", + "mappings": [], + "operation": "DeleteReplicationConfig", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::ReplicationSubnetGroup", + "mappings": [ + { + "source": "ReplicationSubnetGroupDescription", + "target": "ReplicationSubnetGroupDescription" + }, + { + "source": "ReplicationSubnetGroupIdentifier", + "target": "ReplicationSubnetGroupIdentifier" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateReplicationSubnetGroup", + "phase": "create", + "service": "dms" + }, + { + "cfn_type": "AWS::DMS::ReplicationSubnetGroup", + "mappings": [ + { + "source": "ReplicationSubnetGroupIdentifier", + "target": "ReplicationSubnetGroupIdentifier" + } + ], + "operation": "DeleteReplicationSubnetGroup", + "phase": "delete", + "service": "dms" + }, + { + "cfn_type": "AWS::DRS::SourceNetwork", + "mappings": [ + { + "source": "originAccountID", + "target": "OriginAccountID" + }, + { + "source": "originRegion", + "target": "OriginRegion" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcID", + "target": "VpcID" + } + ], + "operation": "CreateSourceNetwork", + "phase": "create", + "service": "drs" + }, + { + "cfn_type": "AWS::DRS::SourceNetwork", + "mappings": [], + "operation": "DeleteSourceNetwork", + "phase": "delete", + "service": "drs" + }, + { + "cfn_type": "AWS::DSQL::Cluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "deletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + }, + { + "source": "kmsEncryptionKey", + "target": "KmsEncryptionKey" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "dsql" + }, + { + "cfn_type": "AWS::DSQL::Cluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "dsql" + }, + { + "cfn_type": "AWS::DataBrew::Dataset", + "mappings": [ + { + "source": "Format", + "target": "Format" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDataset", + "phase": "create", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Dataset", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteDataset", + "phase": "delete", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Job", + "mappings": [ + { + "source": "DatasetName", + "target": "DatasetName" + }, + { + "source": "EncryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "EncryptionMode", + "target": "EncryptionMode" + }, + { + "source": "LogSubscription", + "target": "LogSubscription" + }, + { + "source": "MaxCapacity", + "target": "MaxCapacity" + }, + { + "source": "MaxRetries", + "target": "MaxRetries" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ProjectName", + "target": "ProjectName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Timeout", + "target": "Timeout" + } + ], + "operation": "CreateRecipeJob", + "phase": "create", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Job", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteJob", + "phase": "delete", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Project", + "mappings": [ + { + "source": "DatasetName", + "target": "DatasetName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RecipeName", + "target": "RecipeName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateProject", + "phase": "create", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Project", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteProject", + "phase": "delete", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Recipe", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRecipe", + "phase": "create", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Ruleset", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TargetArn", + "target": "TargetArn" + } + ], + "operation": "CreateRuleset", + "phase": "create", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Ruleset", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteRuleset", + "phase": "delete", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Schedule", + "mappings": [ + { + "source": "CronExpression", + "target": "CronExpression" + }, + { + "source": "JobNames", + "target": "JobNames" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSchedule", + "phase": "create", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataBrew::Schedule", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteSchedule", + "phase": "delete", + "service": "databrew" + }, + { + "cfn_type": "AWS::DataExchange::DataSet", + "mappings": [ + { + "source": "AssetType", + "target": "AssetType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDataSet", + "phase": "create", + "service": "dataexchange" + }, + { + "cfn_type": "AWS::DataExchange::DataSet", + "mappings": [], + "operation": "DeleteDataSet", + "phase": "delete", + "service": "dataexchange" + }, + { + "cfn_type": "AWS::DataPipeline::Pipeline", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreatePipeline", + "phase": "create", + "service": "datapipeline" + }, + { + "cfn_type": "AWS::DataPipeline::Pipeline", + "mappings": [], + "operation": "DeletePipeline", + "phase": "delete", + "service": "datapipeline" + }, + { + "cfn_type": "AWS::DataSync::Agent", + "mappings": [ + { + "source": "ActivationKey", + "target": "ActivationKey" + }, + { + "source": "AgentName", + "target": "AgentName" + }, + { + "source": "SecurityGroupArns", + "target": "SecurityGroupArns" + }, + { + "source": "SubnetArns", + "target": "SubnetArns" + }, + { + "source": "VpcEndpointId", + "target": "VpcEndpointId" + } + ], + "operation": "CreateAgent", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::Agent", + "mappings": [], + "operation": "DeleteAgent", + "phase": "delete", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationAzureBlob", + "mappings": [ + { + "source": "AgentArns", + "target": "AgentArns" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationAzureBlob", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationEFS", + "mappings": [ + { + "source": "AccessPointArn", + "target": "AccessPointArn" + }, + { + "source": "EfsFilesystemArn", + "target": "EfsFilesystemArn" + }, + { + "source": "FileSystemAccessRoleArn", + "target": "FileSystemAccessRoleArn" + }, + { + "source": "InTransitEncryption", + "target": "InTransitEncryption" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationEfs", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationFSxLustre", + "mappings": [ + { + "source": "FsxFilesystemArn", + "target": "FsxFilesystemArn" + }, + { + "source": "SecurityGroupArns", + "target": "SecurityGroupArns" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationFsxLustre", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationFSxONTAP", + "mappings": [ + { + "source": "SecurityGroupArns", + "target": "SecurityGroupArns" + }, + { + "source": "StorageVirtualMachineArn", + "target": "StorageVirtualMachineArn" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationFsxOntap", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationFSxOpenZFS", + "mappings": [ + { + "source": "FsxFilesystemArn", + "target": "FsxFilesystemArn" + }, + { + "source": "SecurityGroupArns", + "target": "SecurityGroupArns" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationFsxOpenZfs", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationFSxWindows", + "mappings": [ + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "FsxFilesystemArn", + "target": "FsxFilesystemArn" + }, + { + "source": "Password", + "target": "Password" + }, + { + "source": "SecurityGroupArns", + "target": "SecurityGroupArns" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + }, + { + "source": "User", + "target": "User" + } + ], + "operation": "CreateLocationFsxWindows", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationHDFS", + "mappings": [ + { + "source": "AgentArns", + "target": "AgentArns" + }, + { + "source": "AuthenticationType", + "target": "AuthenticationType" + }, + { + "source": "BlockSize", + "target": "BlockSize" + }, + { + "source": "KerberosPrincipal", + "target": "KerberosPrincipal" + }, + { + "source": "KmsKeyProviderUri", + "target": "KmsKeyProviderUri" + }, + { + "source": "ReplicationFactor", + "target": "ReplicationFactor" + }, + { + "source": "SimpleUser", + "target": "SimpleUser" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationHdfs", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationNFS", + "mappings": [ + { + "source": "ServerHostname", + "target": "ServerHostname" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationNfs", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationObjectStorage", + "mappings": [ + { + "source": "AccessKey", + "target": "AccessKey" + }, + { + "source": "AgentArns", + "target": "AgentArns" + }, + { + "source": "BucketName", + "target": "BucketName" + }, + { + "source": "SecretKey", + "target": "SecretKey" + }, + { + "source": "ServerHostname", + "target": "ServerHostname" + }, + { + "source": "ServerPort", + "target": "ServerPort" + }, + { + "source": "ServerProtocol", + "target": "ServerProtocol" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationObjectStorage", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationS3", + "mappings": [ + { + "source": "S3BucketArn", + "target": "S3BucketArn" + }, + { + "source": "S3StorageClass", + "target": "S3StorageClass" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + } + ], + "operation": "CreateLocationS3", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::LocationSMB", + "mappings": [ + { + "source": "AgentArns", + "target": "AgentArns" + }, + { + "source": "AuthenticationType", + "target": "AuthenticationType" + }, + { + "source": "DnsIpAddresses", + "target": "DnsIpAddresses" + }, + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "KerberosPrincipal", + "target": "KerberosPrincipal" + }, + { + "source": "Password", + "target": "Password" + }, + { + "source": "ServerHostname", + "target": "ServerHostname" + }, + { + "source": "Subdirectory", + "target": "Subdirectory" + }, + { + "source": "User", + "target": "User" + } + ], + "operation": "CreateLocationSmb", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::Task", + "mappings": [ + { + "source": "CloudWatchLogGroupArn", + "target": "CloudWatchLogGroupArn" + }, + { + "source": "DestinationLocationArn", + "target": "DestinationLocationArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SourceLocationArn", + "target": "SourceLocationArn" + }, + { + "source": "TaskMode", + "target": "TaskMode" + } + ], + "operation": "CreateTask", + "phase": "create", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataSync::Task", + "mappings": [], + "operation": "DeleteTask", + "phase": "delete", + "service": "datasync" + }, + { + "cfn_type": "AWS::DataZone::Connection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "enableTrustedIdentityPropagation", + "target": "EnableTrustedIdentityPropagation" + }, + { + "source": "environmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "scope", + "target": "Scope" + } + ], + "operation": "CreateConnection", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Connection", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteConnection", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::DataSource", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "connectionIdentifier", + "target": "ConnectionIdentifier" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "enableSetting", + "target": "EnableSetting" + }, + { + "source": "environmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectIdentifier", + "target": "ProjectIdentifier" + }, + { + "source": "publishOnImport", + "target": "PublishOnImport" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateDataSource", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::DataSource", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Domain", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainExecutionRole", + "target": "DomainExecutionRole" + }, + { + "source": "domainVersion", + "target": "DomainVersion" + }, + { + "source": "kmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "serviceRole", + "target": "ServiceRole" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Domain", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteDomain", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::DomainUnit", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "parentDomainUnitIdentifier", + "target": "ParentDomainUnitIdentifier" + } + ], + "operation": "CreateDomainUnit", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::DomainUnit", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteDomainUnit", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Environment", + "mappings": [ + { + "source": "deploymentOrder", + "target": "DeploymentOrder" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentAccountIdentifier", + "target": "EnvironmentAccountIdentifier" + }, + { + "source": "environmentAccountRegion", + "target": "EnvironmentAccountRegion" + }, + { + "source": "environmentBlueprintIdentifier", + "target": "EnvironmentBlueprintIdentifier" + }, + { + "source": "environmentConfigurationId", + "target": "EnvironmentConfigurationId" + }, + { + "source": "environmentProfileIdentifier", + "target": "EnvironmentProfileIdentifier" + }, + { + "source": "glossaryTerms", + "target": "GlossaryTerms" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectIdentifier", + "target": "ProjectIdentifier" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Environment", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::EnvironmentActions", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateEnvironmentAction", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::EnvironmentActions", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "identifier", + "target": "Identifier" + } + ], + "operation": "DeleteEnvironmentAction", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::EnvironmentBlueprintConfiguration", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "enabledRegions", + "target": "EnabledRegions" + }, + { + "source": "environmentBlueprintIdentifier", + "target": "EnvironmentBlueprintIdentifier" + }, + { + "source": "environmentRolePermissionBoundary", + "target": "EnvironmentRolePermissionBoundary" + }, + { + "source": "manageAccessRoleArn", + "target": "ManageAccessRoleArn" + }, + { + "source": "provisioningRoleArn", + "target": "ProvisioningRoleArn" + } + ], + "operation": "PutEnvironmentBlueprintConfiguration", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::EnvironmentBlueprintConfiguration", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentBlueprintIdentifier", + "target": "EnvironmentBlueprintIdentifier" + } + ], + "operation": "DeleteEnvironmentBlueprintConfiguration", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::EnvironmentProfile", + "mappings": [ + { + "source": "awsAccountId", + "target": "AwsAccountId" + }, + { + "source": "awsAccountRegion", + "target": "AwsAccountRegion" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentBlueprintIdentifier", + "target": "EnvironmentBlueprintIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectIdentifier", + "target": "ProjectIdentifier" + } + ], + "operation": "CreateEnvironmentProfile", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::EnvironmentProfile", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteEnvironmentProfile", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::FormType", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "owningProjectIdentifier", + "target": "OwningProjectIdentifier" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "CreateFormType", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::FormType", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteFormType", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::GroupProfile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "groupIdentifier", + "target": "GroupIdentifier" + }, + { + "source": "rolePrincipalArn", + "target": "RolePrincipalArn" + } + ], + "operation": "CreateGroupProfile", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Owner", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "entityIdentifier", + "target": "EntityIdentifier" + }, + { + "source": "entityType", + "target": "EntityType" + } + ], + "operation": "AddEntityOwner", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Owner", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "entityIdentifier", + "target": "EntityIdentifier" + }, + { + "source": "entityType", + "target": "EntityType" + } + ], + "operation": "RemoveEntityOwner", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::PolicyGrant", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "entityIdentifier", + "target": "EntityIdentifier" + }, + { + "source": "entityType", + "target": "EntityType" + }, + { + "source": "policyType", + "target": "PolicyType" + } + ], + "operation": "AddPolicyGrant", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::PolicyGrant", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "entityIdentifier", + "target": "EntityIdentifier" + }, + { + "source": "entityType", + "target": "EntityType" + }, + { + "source": "policyType", + "target": "PolicyType" + } + ], + "operation": "RemovePolicyGrant", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Project", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "domainUnitId", + "target": "DomainUnitId" + }, + { + "source": "glossaryTerms", + "target": "GlossaryTerms" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectCategory", + "target": "ProjectCategory" + }, + { + "source": "projectExecutionRole", + "target": "ProjectExecutionRole" + }, + { + "source": "projectProfileId", + "target": "ProjectProfileId" + } + ], + "operation": "CreateProject", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::Project", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteProject", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::ProjectMembership", + "mappings": [ + { + "source": "designation", + "target": "Designation" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "projectIdentifier", + "target": "ProjectIdentifier" + } + ], + "operation": "CreateProjectMembership", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::ProjectMembership", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "projectIdentifier", + "target": "ProjectIdentifier" + } + ], + "operation": "DeleteProjectMembership", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::ProjectProfile", + "mappings": [ + { + "source": "allowCustomProjectResourceTags", + "target": "AllowCustomProjectResourceTags" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "domainUnitIdentifier", + "target": "DomainUnitIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectResourceTagsDescription", + "target": "ProjectResourceTagsDescription" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "CreateProjectProfile", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::ProjectProfile", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + } + ], + "operation": "DeleteProjectProfile", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::SubscriptionTarget", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicableAssetTypes", + "target": "ApplicableAssetTypes" + }, + { + "source": "authorizedPrincipals", + "target": "AuthorizedPrincipals" + }, + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "manageAccessRole", + "target": "ManageAccessRole" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "provider", + "target": "Provider" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateSubscriptionTarget", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::SubscriptionTarget", + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "environmentIdentifier", + "target": "EnvironmentIdentifier" + } + ], + "operation": "DeleteSubscriptionTarget", + "phase": "delete", + "service": "datazone" + }, + { + "cfn_type": "AWS::DataZone::UserProfile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainIdentifier", + "target": "DomainIdentifier" + }, + { + "source": "sessionName", + "target": "SessionName" + }, + { + "source": "userIdentifier", + "target": "UserIdentifier" + }, + { + "source": "userType", + "target": "UserType" + } + ], + "operation": "CreateUserProfile", + "phase": "create", + "service": "datazone" + }, + { + "cfn_type": "AWS::Deadline::Farm", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "costScaleFactor", + "target": "CostScaleFactor" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateFarm", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Farm", + "mappings": [], + "operation": "DeleteFarm", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Fleet", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "maxWorkerCount", + "target": "MaxWorkerCount" + }, + { + "source": "minWorkerCount", + "target": "MinWorkerCount" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateFleet", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Fleet", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + } + ], + "operation": "DeleteFleet", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::LicenseEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreateLicenseEndpoint", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::LicenseEndpoint", + "mappings": [], + "operation": "DeleteLicenseEndpoint", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Limit", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "amountRequirementName", + "target": "AmountRequirementName" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "maxCount", + "target": "MaxCount" + } + ], + "operation": "CreateLimit", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Limit", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + } + ], + "operation": "DeleteLimit", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::MeteredProduct", + "mappings": [ + { + "source": "licenseEndpointId", + "target": "LicenseEndpointId" + }, + { + "source": "productId", + "target": "ProductId" + } + ], + "operation": "PutMeteredProduct", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::MeteredProduct", + "mappings": [ + { + "source": "licenseEndpointId", + "target": "LicenseEndpointId" + }, + { + "source": "productId", + "target": "ProductId" + } + ], + "operation": "DeleteMeteredProduct", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Monitor", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "identityCenterInstanceArn", + "target": "IdentityCenterInstanceArn" + }, + { + "source": "identityCenterRegion", + "target": "IdentityCenterRegion" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "subdomain", + "target": "Subdomain" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateMonitor", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Monitor", + "mappings": [], + "operation": "DeleteMonitor", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Queue", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "allowedStorageProfileIds", + "target": "AllowedStorageProfileIds" + }, + { + "source": "defaultBudgetAction", + "target": "DefaultBudgetAction" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "requiredFileSystemLocationNames", + "target": "RequiredFileSystemLocationNames" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateQueue", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::Queue", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + } + ], + "operation": "DeleteQueue", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::QueueEnvironment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "priority", + "target": "Priority" + }, + { + "source": "queueId", + "target": "QueueId" + }, + { + "source": "template", + "target": "Template" + }, + { + "source": "templateType", + "target": "TemplateType" + } + ], + "operation": "CreateQueueEnvironment", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::QueueEnvironment", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "queueId", + "target": "QueueId" + } + ], + "operation": "DeleteQueueEnvironment", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::QueueFleetAssociation", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "fleetId", + "target": "FleetId" + }, + { + "source": "queueId", + "target": "QueueId" + } + ], + "operation": "CreateQueueFleetAssociation", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::QueueFleetAssociation", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "fleetId", + "target": "FleetId" + }, + { + "source": "queueId", + "target": "QueueId" + } + ], + "operation": "DeleteQueueFleetAssociation", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::QueueLimitAssociation", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "limitId", + "target": "LimitId" + }, + { + "source": "queueId", + "target": "QueueId" + } + ], + "operation": "CreateQueueLimitAssociation", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::QueueLimitAssociation", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "limitId", + "target": "LimitId" + }, + { + "source": "queueId", + "target": "QueueId" + } + ], + "operation": "DeleteQueueLimitAssociation", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::StorageProfile", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "farmId", + "target": "FarmId" + }, + { + "source": "osFamily", + "target": "OsFamily" + } + ], + "operation": "CreateStorageProfile", + "phase": "create", + "service": "deadline" + }, + { + "cfn_type": "AWS::Deadline::StorageProfile", + "mappings": [ + { + "source": "farmId", + "target": "FarmId" + } + ], + "operation": "DeleteStorageProfile", + "phase": "delete", + "service": "deadline" + }, + { + "cfn_type": "AWS::Detective::Graph", + "mappings": [ + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateGraph", + "phase": "create", + "service": "detective" + }, + { + "cfn_type": "AWS::Detective::Graph", + "mappings": [], + "operation": "DeleteGraph", + "phase": "delete", + "service": "detective" + }, + { + "cfn_type": "AWS::Detective::MemberInvitation", + "mappings": [ + { + "source": "DisableEmailNotification", + "target": "DisableEmailNotification" + }, + { + "source": "GraphArn", + "target": "GraphArn" + }, + { + "source": "Message", + "target": "Message" + } + ], + "operation": "CreateMembers", + "phase": "create", + "service": "detective" + }, + { + "cfn_type": "AWS::DevOpsAgent::AgentSpace", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "locale", + "target": "Locale" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAgentSpace", + "phase": "create", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::AgentSpace", + "mappings": [], + "operation": "DeleteAgentSpace", + "phase": "delete", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Asset", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + }, + { + "source": "assetType", + "target": "AssetType" + } + ], + "operation": "CreateAsset", + "phase": "create", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Asset", + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + } + ], + "operation": "DeleteAsset", + "phase": "delete", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Association", + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + }, + { + "source": "serviceId", + "target": "ServiceId" + } + ], + "operation": "AssociateService", + "phase": "create", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::PrivateConnection", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePrivateConnection", + "phase": "create", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::PrivateConnection", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeletePrivateConnection", + "phase": "delete", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Service", + "mappings": [ + { + "source": "exchangeUrlPrivateConnectionName", + "target": "ExchangeUrlPrivateConnectionName" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "privateConnectionName", + "target": "PrivateConnectionName" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetUrlPrivateConnectionName", + "target": "TargetUrlPrivateConnectionName" + } + ], + "operation": "RegisterService", + "phase": "create", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Service", + "mappings": [], + "operation": "DeregisterService", + "phase": "delete", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Trigger", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + }, + { + "source": "status", + "target": "Status" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateTrigger", + "phase": "create", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsAgent::Trigger", + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + } + ], + "operation": "DeleteTrigger", + "phase": "delete", + "service": "devops-agent" + }, + { + "cfn_type": "AWS::DevOpsGuru::NotificationChannel", + "mappings": [], + "operation": "RemoveNotificationChannel", + "phase": "delete", + "service": "devops-guru" + }, + { + "cfn_type": "AWS::DeviceFarm::DevicePool", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "maxDevices", + "target": "MaxDevices" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectArn", + "target": "ProjectArn" + } + ], + "operation": "CreateDevicePool", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::DevicePool", + "mappings": [], + "operation": "DeleteDevicePool", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::InstanceProfile", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "excludeAppPackagesFromCleanup", + "target": "ExcludeAppPackagesFromCleanup" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "packageCleanup", + "target": "PackageCleanup" + }, + { + "source": "rebootAfterUse", + "target": "RebootAfterUse" + } + ], + "operation": "CreateInstanceProfile", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::InstanceProfile", + "mappings": [], + "operation": "DeleteInstanceProfile", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::NetworkProfile", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "downlinkBandwidthBits", + "target": "DownlinkBandwidthBits" + }, + { + "source": "downlinkDelayMs", + "target": "DownlinkDelayMs" + }, + { + "source": "downlinkJitterMs", + "target": "DownlinkJitterMs" + }, + { + "source": "downlinkLossPercent", + "target": "DownlinkLossPercent" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectArn", + "target": "ProjectArn" + }, + { + "source": "uplinkBandwidthBits", + "target": "UplinkBandwidthBits" + }, + { + "source": "uplinkDelayMs", + "target": "UplinkDelayMs" + }, + { + "source": "uplinkJitterMs", + "target": "UplinkJitterMs" + }, + { + "source": "uplinkLossPercent", + "target": "UplinkLossPercent" + } + ], + "operation": "CreateNetworkProfile", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::NetworkProfile", + "mappings": [], + "operation": "DeleteNetworkProfile", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::Project", + "mappings": [ + { + "source": "defaultJobTimeoutMinutes", + "target": "DefaultJobTimeoutMinutes" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateProject", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::Project", + "mappings": [], + "operation": "DeleteProject", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::TestGridProject", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateTestGridProject", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::TestGridProject", + "mappings": [], + "operation": "DeleteTestGridProject", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::Upload", + "mappings": [ + { + "source": "contentType", + "target": "ContentType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "projectArn", + "target": "ProjectArn" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateUpload", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::Upload", + "mappings": [], + "operation": "DeleteUpload", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::VPCEConfiguration", + "mappings": [ + { + "source": "serviceDnsName", + "target": "ServiceDnsName" + }, + { + "source": "vpceConfigurationDescription", + "target": "VpceConfigurationDescription" + }, + { + "source": "vpceConfigurationName", + "target": "VpceConfigurationName" + }, + { + "source": "vpceServiceName", + "target": "VpceServiceName" + } + ], + "operation": "CreateVPCEConfiguration", + "phase": "create", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DeviceFarm::VPCEConfiguration", + "mappings": [], + "operation": "DeleteVPCEConfiguration", + "phase": "delete", + "service": "devicefarm" + }, + { + "cfn_type": "AWS::DirectConnect::Connection", + "mappings": [ + { + "source": "bandwidth", + "target": "Bandwidth" + }, + { + "source": "connectionName", + "target": "ConnectionName" + }, + { + "source": "lagId", + "target": "LagId" + }, + { + "source": "location", + "target": "Location" + }, + { + "source": "providerName", + "target": "ProviderName" + }, + { + "source": "requestMACSec", + "target": "RequestMACSec" + } + ], + "operation": "CreateConnection", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::Connection", + "mappings": [], + "operation": "DeleteConnection", + "phase": "delete", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::DirectConnectGateway", + "mappings": [ + { + "source": "directConnectGatewayName", + "target": "DirectConnectGatewayName" + } + ], + "operation": "CreateDirectConnectGateway", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::DirectConnectGateway", + "mappings": [], + "operation": "DeleteDirectConnectGateway", + "phase": "delete", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::DirectConnectGatewayAssociation", + "mappings": [ + { + "source": "directConnectGatewayId", + "target": "DirectConnectGatewayId" + } + ], + "operation": "CreateDirectConnectGatewayAssociation", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::DirectConnectGatewayAssociation", + "mappings": [ + { + "source": "directConnectGatewayId", + "target": "DirectConnectGatewayId" + } + ], + "operation": "DeleteDirectConnectGatewayAssociation", + "phase": "delete", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::Lag", + "mappings": [ + { + "source": "connectionsBandwidth", + "target": "ConnectionsBandwidth" + }, + { + "source": "lagName", + "target": "LagName" + }, + { + "source": "location", + "target": "Location" + }, + { + "source": "providerName", + "target": "ProviderName" + }, + { + "source": "requestMACSec", + "target": "RequestMACSec" + } + ], + "operation": "CreateLag", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::Lag", + "mappings": [], + "operation": "DeleteLag", + "phase": "delete", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::PrivateVirtualInterface", + "mappings": [ + { + "source": "connectionId", + "target": "ConnectionId" + } + ], + "operation": "CreatePrivateVirtualInterface", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::PublicVirtualInterface", + "mappings": [ + { + "source": "connectionId", + "target": "ConnectionId" + } + ], + "operation": "CreatePublicVirtualInterface", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectConnect::TransitVirtualInterface", + "mappings": [ + { + "source": "connectionId", + "target": "ConnectionId" + } + ], + "operation": "CreateTransitVirtualInterface", + "phase": "create", + "service": "directconnect" + }, + { + "cfn_type": "AWS::DirectoryService::SimpleAD", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Password", + "target": "Password" + }, + { + "source": "ShortName", + "target": "ShortName" + }, + { + "source": "Size", + "target": "Size" + } + ], + "operation": "CreateDirectory", + "phase": "create", + "service": "ds" + }, + { + "cfn_type": "AWS::DocDB::DBSubnetGroup", + "mappings": [ + { + "source": "DBSubnetGroupDescription", + "target": "DBSubnetGroupDescription" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateDBSubnetGroup", + "phase": "create", + "service": "docdb" + }, + { + "cfn_type": "AWS::DocDB::DBSubnetGroup", + "mappings": [ + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + } + ], + "operation": "DeleteDBSubnetGroup", + "phase": "delete", + "service": "docdb" + }, + { + "cfn_type": "AWS::DocDB::EventSubscription", + "mappings": [ + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "EventCategories", + "target": "EventCategories" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "SourceIds", + "target": "SourceIds" + }, + { + "source": "SourceType", + "target": "SourceType" + }, + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "CreateEventSubscription", + "phase": "create", + "service": "docdb" + }, + { + "cfn_type": "AWS::DocDB::EventSubscription", + "mappings": [ + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "DeleteEventSubscription", + "phase": "delete", + "service": "docdb" + }, + { + "cfn_type": "AWS::DocDB::GlobalCluster", + "mappings": [ + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + }, + { + "source": "SourceDBClusterIdentifier", + "target": "SourceDBClusterIdentifier" + }, + { + "source": "StorageEncrypted", + "target": "StorageEncrypted" + } + ], + "operation": "CreateGlobalCluster", + "phase": "create", + "service": "docdb" + }, + { + "cfn_type": "AWS::DocDB::GlobalCluster", + "mappings": [ + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + } + ], + "operation": "DeleteGlobalCluster", + "phase": "delete", + "service": "docdb" + }, + { + "cfn_type": "AWS::DocDBElastic::Cluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "adminUserName", + "target": "AdminUserName" + }, + { + "source": "adminUserPassword", + "target": "AdminUserPassword" + }, + { + "source": "authType", + "target": "AuthType" + }, + { + "source": "backupRetentionPeriod", + "target": "BackupRetentionPeriod" + }, + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "preferredBackupWindow", + "target": "PreferredBackupWindow" + }, + { + "source": "preferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "shardCapacity", + "target": "ShardCapacity" + }, + { + "source": "shardCount", + "target": "ShardCount" + }, + { + "source": "shardInstanceCount", + "target": "ShardInstanceCount" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "docdb-elastic" + }, + { + "cfn_type": "AWS::DocDBElastic::Cluster", + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "docdb-elastic" + }, + { + "cfn_type": "AWS::DynamoDB::Backup", + "mappings": [ + { + "source": "BackupName", + "target": "BackupName" + }, + { + "source": "TableName", + "target": "TableName" + } + ], + "operation": "CreateBackup", + "phase": "create", + "service": "dynamodb" + }, + { + "cfn_type": "AWS::DynamoDB::Backup", + "mappings": [], + "operation": "DeleteBackup", + "phase": "delete", + "service": "dynamodb" + }, + { + "cfn_type": "AWS::DynamoDB::Table", + "mappings": [ + { + "source": "BillingMode", + "target": "BillingMode" + }, + { + "source": "DeletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + }, + { + "source": "TableClass", + "target": "TableClass" + }, + { + "source": "TableName", + "target": "TableName" + } + ], + "operation": "CreateTable", + "phase": "create", + "service": "dynamodb" + }, + { + "cfn_type": "AWS::DynamoDB::Table", + "mappings": [ + { + "source": "TableName", + "target": "TableName" + } + ], + "operation": "DeleteTable", + "phase": "delete", + "service": "dynamodb" + }, + { + "cfn_type": "AWS::EC2::CapacityManagerDataExport", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "OutputFormat", + "target": "OutputFormat" + }, + { + "source": "S3BucketName", + "target": "S3BucketName" + }, + { + "source": "S3BucketPrefix", + "target": "S3BucketPrefix" + }, + { + "source": "Schedule", + "target": "Schedule" + } + ], + "operation": "CreateCapacityManagerDataExport", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CapacityManagerDataExport", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteCapacityManagerDataExport", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CapacityReservation", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "AvailabilityZoneId", + "target": "AvailabilityZoneId" + }, + { + "source": "EbsOptimized", + "target": "EbsOptimized" + }, + { + "source": "EndDateType", + "target": "EndDateType" + }, + { + "source": "EphemeralStorage", + "target": "EphemeralStorage" + }, + { + "source": "InstanceCount", + "target": "InstanceCount" + }, + { + "source": "InstanceMatchCriteria", + "target": "InstanceMatchCriteria" + }, + { + "source": "InstancePlatform", + "target": "InstancePlatform" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "OutpostArn", + "target": "OutPostArn" + }, + { + "source": "PlacementGroupArn", + "target": "PlacementGroupArn" + }, + { + "source": "Tenancy", + "target": "Tenancy" + } + ], + "operation": "CreateCapacityReservation", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CapacityReservation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "CancelCapacityReservation", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CapacityReservationFleet", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AllocationStrategy", + "target": "AllocationStrategy" + }, + { + "source": "InstanceMatchCriteria", + "target": "InstanceMatchCriteria" + }, + { + "source": "Tenancy", + "target": "Tenancy" + }, + { + "source": "TotalTargetCapacity", + "target": "TotalTargetCapacity" + } + ], + "operation": "CreateCapacityReservationFleet", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CapacityReservationFleet", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "CancelCapacityReservationFleets", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CarrierGateway", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateCarrierGateway", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CarrierGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteCarrierGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CustomerGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "BgpAsn", + "target": "BgpAsn" + }, + { + "source": "BgpAsnExtended", + "target": "BgpAsnExtended" + }, + { + "source": "CertificateArn", + "target": "CertificateArn" + }, + { + "source": "DeviceName", + "target": "DeviceName" + }, + { + "source": "IpAddress", + "target": "IpAddress" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateCustomerGateway", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::CustomerGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteCustomerGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::DHCPOptions", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteDhcpOptions", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::EC2Fleet", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Context", + "target": "Context" + }, + { + "source": "ExcessCapacityTerminationPolicy", + "target": "ExcessCapacityTerminationPolicy" + }, + { + "source": "ReplaceUnhealthyInstances", + "target": "ReplaceUnhealthyInstances" + }, + { + "source": "TerminateInstancesWithExpiration", + "target": "TerminateInstancesWithExpiration" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateFleet", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::EIPAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "AllocationId", + "target": "AllocationId" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "NetworkInterfaceId", + "target": "NetworkInterfaceId" + }, + { + "source": "PrivateIpAddress", + "target": "PrivateIpAddress" + } + ], + "operation": "AssociateAddress", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::EgressOnlyInternetGateway", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateEgressOnlyInternetGateway", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::EgressOnlyInternetGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteEgressOnlyInternetGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::EnclaveCertificateIamRoleAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CertificateArn", + "target": "CertificateArn" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "AssociateEnclaveCertificateIamRole", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::EnclaveCertificateIamRoleAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CertificateArn", + "target": "CertificateArn" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "DisassociateEnclaveCertificateIamRole", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::FlowLog", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "DeliverCrossAccountRole", + "target": "DeliverCrossAccountRole" + }, + { + "source": "DeliverLogsPermissionArn", + "target": "DeliverLogsPermissionArn" + }, + { + "source": "LogDestination", + "target": "LogDestination" + }, + { + "source": "LogDestinationType", + "target": "LogDestinationType" + }, + { + "source": "LogFormat", + "target": "LogFormat" + }, + { + "source": "LogGroupName", + "target": "LogGroupName" + }, + { + "source": "MaxAggregationInterval", + "target": "MaxAggregationInterval" + }, + { + "source": "ResourceType", + "target": "ResourceType" + }, + { + "source": "TrafficType", + "target": "TrafficType" + } + ], + "operation": "CreateFlowLogs", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::FlowLog", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteFlowLogs", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Host", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AutoPlacement", + "target": "AutoPlacement" + }, + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "HostMaintenance", + "target": "HostMaintenance" + }, + { + "source": "HostRecovery", + "target": "HostRecovery" + }, + { + "source": "InstanceFamily", + "target": "InstanceFamily" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "OutpostArn", + "target": "OutpostArn" + } + ], + "operation": "AllocateHosts", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Host", + "mappings": [], + "operation": "ReleaseHosts", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAM", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnablePrivateGua", + "target": "EnablePrivateGua" + }, + { + "source": "MeteredAccount", + "target": "MeteredAccount" + }, + { + "source": "Tier", + "target": "Tier" + } + ], + "operation": "CreateIpam", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAM", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteIpam", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMAllocation", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Cidr", + "target": "Cidr" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IpamPoolId", + "target": "IpamPoolId" + }, + { + "source": "NetmaskLength", + "target": "NetmaskLength" + } + ], + "operation": "AllocateIpamPoolCidr", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMAllocation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Cidr", + "target": "Cidr" + }, + { + "source": "IpamPoolId", + "target": "IpamPoolId" + } + ], + "operation": "ReleaseIpamPoolAllocation", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPool", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AddressFamily", + "target": "AddressFamily" + }, + { + "source": "AllocationDefaultNetmaskLength", + "target": "AllocationDefaultNetmaskLength" + }, + { + "source": "AllocationMaxNetmaskLength", + "target": "AllocationMaxNetmaskLength" + }, + { + "source": "AllocationMinNetmaskLength", + "target": "AllocationMinNetmaskLength" + }, + { + "source": "AutoImport", + "target": "AutoImport" + }, + { + "source": "AwsService", + "target": "AwsService" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IpamScopeId", + "target": "IpamScopeId" + }, + { + "source": "Locale", + "target": "Locale" + }, + { + "source": "PublicIpSource", + "target": "PublicIpSource" + }, + { + "source": "PubliclyAdvertisable", + "target": "PubliclyAdvertisable" + }, + { + "source": "SourceIpamPoolId", + "target": "SourceIpamPoolId" + } + ], + "operation": "CreateIpamPool", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPool", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteIpamPool", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPoolCidr", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Cidr", + "target": "Cidr" + }, + { + "source": "IpamPoolId", + "target": "IpamPoolId" + }, + { + "source": "NetmaskLength", + "target": "NetmaskLength" + } + ], + "operation": "ProvisionIpamPoolCidr", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPoolCidr", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Cidr", + "target": "Cidr" + }, + { + "source": "IpamPoolId", + "target": "IpamPoolId" + } + ], + "operation": "DeprovisionIpamPoolCidr", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPrefixListResolver", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AddressFamily", + "target": "AddressFamily" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IpamId", + "target": "IpamId" + } + ], + "operation": "CreateIpamPrefixListResolver", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPrefixListResolver", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteIpamPrefixListResolver", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPrefixListResolverTarget", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "DesiredVersion", + "target": "DesiredVersion" + }, + { + "source": "IpamPrefixListResolverId", + "target": "IpamPrefixListResolverId" + }, + { + "source": "PrefixListId", + "target": "PrefixListId" + }, + { + "source": "PrefixListRegion", + "target": "PrefixListRegion" + }, + { + "source": "TrackLatestVersion", + "target": "TrackLatestVersion" + } + ], + "operation": "CreateIpamPrefixListResolverTarget", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMPrefixListResolverTarget", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteIpamPrefixListResolverTarget", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMResourceDiscovery", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateIpamResourceDiscovery", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMResourceDiscovery", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteIpamResourceDiscovery", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMScope", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "IpamId", + "target": "IpamId" + } + ], + "operation": "CreateIpamScope", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::IPAMScope", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteIpamScope", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Instance", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AdditionalInfo", + "target": "AdditionalInfo" + }, + { + "source": "DisableApiTermination", + "target": "DisableApiTermination" + }, + { + "source": "EbsOptimized", + "target": "EbsOptimized" + }, + { + "source": "ImageId", + "target": "ImageId" + }, + { + "source": "InstanceInitiatedShutdownBehavior", + "target": "InstanceInitiatedShutdownBehavior" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "Ipv6AddressCount", + "target": "Ipv6AddressCount" + }, + { + "source": "KernelId", + "target": "KernelId" + }, + { + "source": "KeyName", + "target": "KeyName" + }, + { + "source": "PrivateIpAddress", + "target": "PrivateIpAddress" + }, + { + "source": "RamdiskId", + "target": "RamdiskId" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "SubnetId", + "target": "SubnetId" + }, + { + "source": "UserData", + "target": "UserData" + } + ], + "operation": "RunInstances", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Instance", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "TerminateInstances", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::InstanceConnectEndpoint", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "PreserveClientIp", + "target": "PreserveClientIp" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "SubnetId", + "target": "SubnetId" + } + ], + "operation": "CreateInstanceConnectEndpoint", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::InstanceConnectEndpoint", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteInstanceConnectEndpoint", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::InternetGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteInternetGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::KeyPair", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "KeyFormat", + "target": "KeyFormat" + }, + { + "source": "KeyName", + "target": "KeyName" + }, + { + "source": "KeyType", + "target": "KeyType" + } + ], + "operation": "CreateKeyPair", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::KeyPair", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "KeyName", + "target": "KeyName" + } + ], + "operation": "DeleteKeyPair", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LaunchTemplate", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "LaunchTemplateName", + "target": "LaunchTemplateName" + }, + { + "source": "VersionDescription", + "target": "VersionDescription" + } + ], + "operation": "CreateLaunchTemplate", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LaunchTemplate", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "LaunchTemplateName", + "target": "LaunchTemplateName" + } + ], + "operation": "DeleteLaunchTemplate", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRoute", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "LocalGatewayRouteTableId", + "target": "LocalGatewayRouteTableId" + }, + { + "source": "LocalGatewayVirtualInterfaceGroupId", + "target": "LocalGatewayVirtualInterfaceGroupId" + }, + { + "source": "NetworkInterfaceId", + "target": "NetworkInterfaceId" + } + ], + "operation": "CreateLocalGatewayRoute", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRoute", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "LocalGatewayRouteTableId", + "target": "LocalGatewayRouteTableId" + } + ], + "operation": "DeleteLocalGatewayRoute", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRouteTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "LocalGatewayId", + "target": "LocalGatewayId" + }, + { + "source": "Mode", + "target": "Mode" + } + ], + "operation": "CreateLocalGatewayRouteTable", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRouteTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteLocalGatewayRouteTable", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRouteTableVPCAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "LocalGatewayRouteTableId", + "target": "LocalGatewayRouteTableId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateLocalGatewayRouteTableVpcAssociation", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRouteTableVPCAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteLocalGatewayRouteTableVpcAssociation", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRouteTableVirtualInterfaceGroupAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "LocalGatewayRouteTableId", + "target": "LocalGatewayRouteTableId" + }, + { + "source": "LocalGatewayVirtualInterfaceGroupId", + "target": "LocalGatewayVirtualInterfaceGroupId" + } + ], + "operation": "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayRouteTableVirtualInterfaceGroupAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayVirtualInterface", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "LocalAddress", + "target": "LocalAddress" + }, + { + "source": "LocalGatewayVirtualInterfaceGroupId", + "target": "LocalGatewayVirtualInterfaceGroupId" + }, + { + "source": "OutpostLagId", + "target": "OutpostLagId" + }, + { + "source": "PeerAddress", + "target": "PeerAddress" + }, + { + "source": "PeerBgpAsn", + "target": "PeerBgpAsn" + }, + { + "source": "PeerBgpAsnExtended", + "target": "PeerBgpAsnExtended" + }, + { + "source": "Vlan", + "target": "Vlan" + } + ], + "operation": "CreateLocalGatewayVirtualInterface", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayVirtualInterface", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteLocalGatewayVirtualInterface", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayVirtualInterfaceGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "LocalBgpAsn", + "target": "LocalBgpAsn" + }, + { + "source": "LocalBgpAsnExtended", + "target": "LocalBgpAsnExtended" + }, + { + "source": "LocalGatewayId", + "target": "LocalGatewayId" + } + ], + "operation": "CreateLocalGatewayVirtualInterfaceGroup", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::LocalGatewayVirtualInterfaceGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteLocalGatewayVirtualInterfaceGroup", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NatGateway", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AllocationId", + "target": "AllocationId" + }, + { + "source": "AvailabilityMode", + "target": "AvailabilityMode" + }, + { + "source": "ConnectivityType", + "target": "ConnectivityType" + }, + { + "source": "PrivateIpAddress", + "target": "PrivateIpAddress" + }, + { + "source": "SecondaryAllocationIds", + "target": "SecondaryAllocationIds" + }, + { + "source": "SecondaryPrivateIpAddressCount", + "target": "SecondaryPrivateIpAddressCount" + }, + { + "source": "SecondaryPrivateIpAddresses", + "target": "SecondaryPrivateIpAddresses" + }, + { + "source": "SubnetId", + "target": "SubnetId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateNatGateway", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NatGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNatGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkAcl", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateNetworkAcl", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkAcl", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNetworkAcl", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkAclEntry", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CidrBlock", + "target": "CidrBlock" + }, + { + "source": "Egress", + "target": "Egress" + }, + { + "source": "Ipv6CidrBlock", + "target": "Ipv6CidrBlock" + }, + { + "source": "NetworkAclId", + "target": "NetworkAclId" + }, + { + "source": "RuleAction", + "target": "RuleAction" + }, + { + "source": "RuleNumber", + "target": "RuleNumber" + } + ], + "operation": "CreateNetworkAclEntry", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkAclEntry", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Egress", + "target": "Egress" + }, + { + "source": "NetworkAclId", + "target": "NetworkAclId" + }, + { + "source": "RuleNumber", + "target": "RuleNumber" + } + ], + "operation": "DeleteNetworkAclEntry", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsAccessScope", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNetworkInsightsAccessScope", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsAccessScopeAnalysis", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "NetworkInsightsAccessScopeId", + "target": "NetworkInsightsAccessScopeId" + } + ], + "operation": "StartNetworkInsightsAccessScopeAnalysis", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsAccessScopeAnalysis", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNetworkInsightsAccessScopeAnalysis", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsAnalysis", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AdditionalAccounts", + "target": "AdditionalAccounts" + }, + { + "source": "FilterInArns", + "target": "FilterInArns" + }, + { + "source": "FilterOutArns", + "target": "FilterOutArns" + }, + { + "source": "NetworkInsightsPathId", + "target": "NetworkInsightsPathId" + } + ], + "operation": "StartNetworkInsightsAnalysis", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsAnalysis", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNetworkInsightsAnalysis", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsPath", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Destination", + "target": "Destination" + }, + { + "source": "DestinationIp", + "target": "DestinationIp" + }, + { + "source": "DestinationPort", + "target": "DestinationPort" + }, + { + "source": "Protocol", + "target": "Protocol" + }, + { + "source": "Source", + "target": "Source" + }, + { + "source": "SourceIp", + "target": "SourceIp" + } + ], + "operation": "CreateNetworkInsightsPath", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInsightsPath", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNetworkInsightsPath", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInterface", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnablePrimaryIpv6", + "target": "EnablePrimaryIpv6" + }, + { + "source": "InterfaceType", + "target": "InterfaceType" + }, + { + "source": "Ipv4PrefixCount", + "target": "Ipv4PrefixCount" + }, + { + "source": "Ipv6AddressCount", + "target": "Ipv6AddressCount" + }, + { + "source": "Ipv6PrefixCount", + "target": "Ipv6PrefixCount" + }, + { + "source": "PrivateIpAddress", + "target": "PrivateIpAddress" + }, + { + "source": "SecondaryPrivateIpAddressCount", + "target": "SecondaryPrivateIpAddressCount" + }, + { + "source": "SubnetId", + "target": "SubnetId" + } + ], + "operation": "CreateNetworkInterface", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInterface", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteNetworkInterface", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkInterfaceAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "EnaQueueCount", + "target": "EnaQueueCount" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "NetworkInterfaceId", + "target": "NetworkInterfaceId" + } + ], + "operation": "AttachNetworkInterface", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::NetworkPerformanceMetricSubscription", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Destination", + "target": "Destination" + }, + { + "source": "Metric", + "target": "Metric" + }, + { + "source": "Source", + "target": "Source" + }, + { + "source": "Statistic", + "target": "Statistic" + } + ], + "operation": "EnableAwsNetworkPerformanceMetricSubscription", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::PlacementGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "ParentGroupId", + "target": "ParentGroupId" + }, + { + "source": "PartitionCount", + "target": "PartitionCount" + }, + { + "source": "SpreadLevel", + "target": "SpreadLevel" + }, + { + "source": "Strategy", + "target": "Strategy" + } + ], + "operation": "CreatePlacementGroup", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::PlacementGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeletePlacementGroup", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::PrefixList", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AddressFamily", + "target": "AddressFamily" + }, + { + "source": "MaxEntries", + "target": "MaxEntries" + }, + { + "source": "PrefixListName", + "target": "PrefixListName" + } + ], + "operation": "CreateManagedPrefixList", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::PrefixList", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteManagedPrefixList", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Route", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CarrierGatewayId", + "target": "CarrierGatewayId" + }, + { + "source": "CoreNetworkArn", + "target": "CoreNetworkArn" + }, + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "DestinationIpv6CidrBlock", + "target": "DestinationIpv6CidrBlock" + }, + { + "source": "DestinationPrefixListId", + "target": "DestinationPrefixListId" + }, + { + "source": "EgressOnlyInternetGatewayId", + "target": "EgressOnlyInternetGatewayId" + }, + { + "source": "GatewayId", + "target": "GatewayId" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "LocalGatewayId", + "target": "LocalGatewayId" + }, + { + "source": "NatGatewayId", + "target": "NatGatewayId" + }, + { + "source": "NetworkInterfaceId", + "target": "NetworkInterfaceId" + }, + { + "source": "OdbNetworkArn", + "target": "OdbNetworkArn" + }, + { + "source": "RouteTableId", + "target": "RouteTableId" + }, + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + }, + { + "source": "VpcEndpointId", + "target": "VpcEndpointId" + }, + { + "source": "VpcPeeringConnectionId", + "target": "VpcPeeringConnectionId" + } + ], + "operation": "CreateRoute", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Route", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "DestinationIpv6CidrBlock", + "target": "DestinationIpv6CidrBlock" + }, + { + "source": "DestinationPrefixListId", + "target": "DestinationPrefixListId" + }, + { + "source": "RouteTableId", + "target": "RouteTableId" + } + ], + "operation": "DeleteRoute", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServer", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AmazonSideAsn", + "target": "AmazonSideAsn" + }, + { + "source": "PersistRoutes", + "target": "PersistRoutes" + }, + { + "source": "PersistRoutesDuration", + "target": "PersistRoutesDuration" + }, + { + "source": "SnsNotificationsEnabled", + "target": "SnsNotificationsEnabled" + } + ], + "operation": "CreateRouteServer", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServer", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteRouteServer", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "RouteServerId", + "target": "RouteServerId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "AssociateRouteServer", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "RouteServerId", + "target": "RouteServerId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "DisassociateRouteServer", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerEndpoint", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "RouteServerId", + "target": "RouteServerId" + }, + { + "source": "SubnetId", + "target": "SubnetId" + } + ], + "operation": "CreateRouteServerEndpoint", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerEndpoint", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteRouteServerEndpoint", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerPeer", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "PeerAddress", + "target": "PeerAddress" + }, + { + "source": "RouteServerEndpointId", + "target": "RouteServerEndpointId" + } + ], + "operation": "CreateRouteServerPeer", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerPeer", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteRouteServerPeer", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteServerPropagation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "RouteServerId", + "target": "RouteServerId" + }, + { + "source": "RouteTableId", + "target": "RouteTableId" + } + ], + "operation": "EnableRouteServerPropagation", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteTable", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateRouteTable", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::RouteTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteRouteTable", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SecurityGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateSecurityGroup", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SecurityGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + } + ], + "operation": "DeleteSecurityGroup", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SecurityGroupEgress", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CidrIp", + "target": "CidrIp" + }, + { + "source": "FromPort", + "target": "FromPort" + }, + { + "source": "GroupId", + "target": "GroupId" + }, + { + "source": "IpProtocol", + "target": "IpProtocol" + }, + { + "source": "ToPort", + "target": "ToPort" + } + ], + "operation": "RevokeSecurityGroupEgress", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SecurityGroupIngress", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CidrIp", + "target": "CidrIp" + }, + { + "source": "FromPort", + "target": "FromPort" + }, + { + "source": "GroupId", + "target": "GroupId" + }, + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "IpProtocol", + "target": "IpProtocol" + }, + { + "source": "SourceSecurityGroupName", + "target": "SourceSecurityGroupName" + }, + { + "source": "SourceSecurityGroupOwnerId", + "target": "SourceSecurityGroupOwnerId" + }, + { + "source": "ToPort", + "target": "ToPort" + } + ], + "operation": "RevokeSecurityGroupIngress", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SecurityGroupVpcAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupId", + "target": "GroupId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "AssociateSecurityGroupVpc", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SecurityGroupVpcAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupId", + "target": "GroupId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "DisassociateSecurityGroupVpc", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SnapshotBlockPublicAccess", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "State", + "target": "State" + } + ], + "operation": "EnableSnapshotBlockPublicAccess", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Subnet", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "AvailabilityZoneId", + "target": "AvailabilityZoneId" + }, + { + "source": "CidrBlock", + "target": "CidrBlock" + }, + { + "source": "Ipv4IpamPoolId", + "target": "Ipv4IpamPoolId" + }, + { + "source": "Ipv4NetmaskLength", + "target": "Ipv4NetmaskLength" + }, + { + "source": "Ipv6CidrBlock", + "target": "Ipv6CidrBlock" + }, + { + "source": "Ipv6IpamPoolId", + "target": "Ipv6IpamPoolId" + }, + { + "source": "Ipv6Native", + "target": "Ipv6Native" + }, + { + "source": "Ipv6NetmaskLength", + "target": "Ipv6NetmaskLength" + }, + { + "source": "OutpostArn", + "target": "OutpostArn" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateSubnet", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Subnet", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteSubnet", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SubnetCidrBlock", + "mappings": [ + { + "source": "Ipv6CidrBlock", + "target": "Ipv6CidrBlock" + }, + { + "source": "Ipv6IpamPoolId", + "target": "Ipv6IpamPoolId" + }, + { + "source": "Ipv6NetmaskLength", + "target": "Ipv6NetmaskLength" + }, + { + "source": "SubnetId", + "target": "SubnetId" + } + ], + "operation": "AssociateSubnetCidrBlock", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::SubnetCidrBlock", + "mappings": [], + "operation": "DisassociateSubnetCidrBlock", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorFilter", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateTrafficMirrorFilter", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorFilter", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTrafficMirrorFilter", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorFilterRule", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "Protocol", + "target": "Protocol" + }, + { + "source": "RuleAction", + "target": "RuleAction" + }, + { + "source": "RuleNumber", + "target": "RuleNumber" + }, + { + "source": "SourceCidrBlock", + "target": "SourceCidrBlock" + }, + { + "source": "TrafficDirection", + "target": "TrafficDirection" + }, + { + "source": "TrafficMirrorFilterId", + "target": "TrafficMirrorFilterId" + } + ], + "operation": "CreateTrafficMirrorFilterRule", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorFilterRule", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTrafficMirrorFilterRule", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorSession", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "NetworkInterfaceId", + "target": "NetworkInterfaceId" + }, + { + "source": "PacketLength", + "target": "PacketLength" + }, + { + "source": "SessionNumber", + "target": "SessionNumber" + }, + { + "source": "TrafficMirrorFilterId", + "target": "TrafficMirrorFilterId" + }, + { + "source": "TrafficMirrorTargetId", + "target": "TrafficMirrorTargetId" + }, + { + "source": "VirtualNetworkId", + "target": "VirtualNetworkId" + } + ], + "operation": "CreateTrafficMirrorSession", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorSession", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTrafficMirrorSession", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorTarget", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GatewayLoadBalancerEndpointId", + "target": "GatewayLoadBalancerEndpointId" + }, + { + "source": "NetworkInterfaceId", + "target": "NetworkInterfaceId" + }, + { + "source": "NetworkLoadBalancerArn", + "target": "NetworkLoadBalancerArn" + } + ], + "operation": "CreateTrafficMirrorTarget", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TrafficMirrorTarget", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTrafficMirrorTarget", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateTransitGateway", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayConnect", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransportTransitGatewayAttachmentId", + "target": "TransportTransitGatewayAttachmentId" + } + ], + "operation": "CreateTransitGatewayConnect", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayConnect", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayConnect", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayConnectPeer", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + } + ], + "operation": "CreateTransitGatewayConnectPeer", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayConnectPeer", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayConnectPeer", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMeteringPolicy", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "MiddleboxAttachmentIds", + "target": "MiddleboxAttachmentIds" + }, + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + } + ], + "operation": "CreateTransitGatewayMeteringPolicy", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMeteringPolicy", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayMeteringPolicy", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMeteringPolicyEntry", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "DestinationPortRange", + "target": "DestinationPortRange" + }, + { + "source": "DestinationTransitGatewayAttachmentId", + "target": "DestinationTransitGatewayAttachmentId" + }, + { + "source": "DestinationTransitGatewayAttachmentType", + "target": "DestinationTransitGatewayAttachmentType" + }, + { + "source": "MeteredAccount", + "target": "MeteredAccount" + }, + { + "source": "PolicyRuleNumber", + "target": "PolicyRuleNumber" + }, + { + "source": "Protocol", + "target": "Protocol" + }, + { + "source": "SourceCidrBlock", + "target": "SourceCidrBlock" + }, + { + "source": "SourcePortRange", + "target": "SourcePortRange" + }, + { + "source": "SourceTransitGatewayAttachmentId", + "target": "SourceTransitGatewayAttachmentId" + }, + { + "source": "SourceTransitGatewayAttachmentType", + "target": "SourceTransitGatewayAttachmentType" + }, + { + "source": "TransitGatewayMeteringPolicyId", + "target": "TransitGatewayMeteringPolicyId" + } + ], + "operation": "CreateTransitGatewayMeteringPolicyEntry", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMeteringPolicyEntry", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "PolicyRuleNumber", + "target": "PolicyRuleNumber" + }, + { + "source": "TransitGatewayMeteringPolicyId", + "target": "TransitGatewayMeteringPolicyId" + } + ], + "operation": "DeleteTransitGatewayMeteringPolicyEntry", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastDomain", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + } + ], + "operation": "CreateTransitGatewayMulticastDomain", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastDomain", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayMulticastDomain", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastDomainAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayMulticastDomainId", + "target": "TransitGatewayMulticastDomainId" + } + ], + "operation": "AssociateTransitGatewayMulticastDomain", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastDomainAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayMulticastDomainId", + "target": "TransitGatewayMulticastDomainId" + } + ], + "operation": "DisassociateTransitGatewayMulticastDomain", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastGroupMember", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupIpAddress", + "target": "GroupIpAddress" + }, + { + "source": "TransitGatewayMulticastDomainId", + "target": "TransitGatewayMulticastDomainId" + } + ], + "operation": "RegisterTransitGatewayMulticastGroupMembers", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastGroupMember", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupIpAddress", + "target": "GroupIpAddress" + }, + { + "source": "TransitGatewayMulticastDomainId", + "target": "TransitGatewayMulticastDomainId" + } + ], + "operation": "DeregisterTransitGatewayMulticastGroupMembers", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastGroupSource", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupIpAddress", + "target": "GroupIpAddress" + }, + { + "source": "TransitGatewayMulticastDomainId", + "target": "TransitGatewayMulticastDomainId" + } + ], + "operation": "RegisterTransitGatewayMulticastGroupSources", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayMulticastGroupSource", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "GroupIpAddress", + "target": "GroupIpAddress" + }, + { + "source": "TransitGatewayMulticastDomainId", + "target": "TransitGatewayMulticastDomainId" + } + ], + "operation": "DeregisterTransitGatewayMulticastGroupSources", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPeeringAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "PeerAccountId", + "target": "PeerAccountId" + }, + { + "source": "PeerRegion", + "target": "PeerRegion" + }, + { + "source": "PeerTransitGatewayId", + "target": "PeerTransitGatewayId" + }, + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + } + ], + "operation": "CreateTransitGatewayPeeringAttachment", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPeeringAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayPeeringAttachment", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPolicyTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + } + ], + "operation": "CreateTransitGatewayPolicyTable", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPolicyTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayPolicyTable", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPolicyTableAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayPolicyTableId", + "target": "TransitGatewayPolicyTableId" + } + ], + "operation": "AssociateTransitGatewayPolicyTable", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPolicyTableAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayPolicyTableId", + "target": "TransitGatewayPolicyTableId" + } + ], + "operation": "DisassociateTransitGatewayPolicyTable", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPolicyTableEntry", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "PolicyRuleNumber", + "target": "PolicyRuleNumber" + }, + { + "source": "TargetRouteTableId", + "target": "TargetRouteTableId" + }, + { + "source": "TransitGatewayPolicyTableId", + "target": "TransitGatewayPolicyTableId" + } + ], + "operation": "CreateTransitGatewayPolicyTableEntry", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayPolicyTableEntry", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "PolicyRuleNumber", + "target": "PolicyRuleNumber" + }, + { + "source": "TransitGatewayPolicyTableId", + "target": "TransitGatewayPolicyTableId" + } + ], + "operation": "DeleteTransitGatewayPolicyTableEntry", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRoute", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Blackhole", + "target": "Blackhole" + }, + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayRouteTableId", + "target": "TransitGatewayRouteTableId" + } + ], + "operation": "CreateTransitGatewayRoute", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRoute", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "TransitGatewayRouteTableId", + "target": "TransitGatewayRouteTableId" + } + ], + "operation": "DeleteTransitGatewayRoute", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRouteTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + } + ], + "operation": "CreateTransitGatewayRouteTable", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRouteTable", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayRouteTable", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRouteTableAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayRouteTableId", + "target": "TransitGatewayRouteTableId" + } + ], + "operation": "AssociateTransitGatewayRouteTable", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRouteTableAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayRouteTableId", + "target": "TransitGatewayRouteTableId" + } + ], + "operation": "DisassociateTransitGatewayRouteTable", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayRouteTablePropagation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayAttachmentId", + "target": "TransitGatewayAttachmentId" + }, + { + "source": "TransitGatewayRouteTableId", + "target": "TransitGatewayRouteTableId" + } + ], + "operation": "EnableTransitGatewayRouteTablePropagation", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayVpcAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateTransitGatewayVpcAttachment", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::TransitGatewayVpcAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteTransitGatewayVpcAttachment", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPC", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CidrBlock", + "target": "CidrBlock" + }, + { + "source": "InstanceTenancy", + "target": "InstanceTenancy" + }, + { + "source": "Ipv4IpamPoolId", + "target": "Ipv4IpamPoolId" + }, + { + "source": "Ipv4NetmaskLength", + "target": "Ipv4NetmaskLength" + } + ], + "operation": "CreateVpc", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPC", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpc", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCBlockPublicAccessExclusion", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "InternetGatewayExclusionMode", + "target": "InternetGatewayExclusionMode" + }, + { + "source": "SubnetId", + "target": "SubnetId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcBlockPublicAccessExclusion", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCBlockPublicAccessExclusion", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpcBlockPublicAccessExclusion", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCCidrBlock", + "mappings": [ + { + "source": "AmazonProvidedIpv6CidrBlock", + "target": "AmazonProvidedIpv6CidrBlock" + }, + { + "source": "CidrBlock", + "target": "CidrBlock" + }, + { + "source": "Ipv4IpamPoolId", + "target": "Ipv4IpamPoolId" + }, + { + "source": "Ipv4NetmaskLength", + "target": "Ipv4NetmaskLength" + }, + { + "source": "Ipv6CidrBlock", + "target": "Ipv6CidrBlock" + }, + { + "source": "Ipv6CidrBlockNetworkBorderGroup", + "target": "Ipv6CidrBlockNetworkBorderGroup" + }, + { + "source": "Ipv6IpamPoolId", + "target": "Ipv6IpamPoolId" + }, + { + "source": "Ipv6NetmaskLength", + "target": "Ipv6NetmaskLength" + }, + { + "source": "Ipv6Pool", + "target": "Ipv6Pool" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "AssociateVpcCidrBlock", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCCidrBlock", + "mappings": [], + "operation": "DisassociateVpcCidrBlock", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCDHCPOptionsAssociation", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "DhcpOptionsId", + "target": "DhcpOptionsId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "AssociateDhcpOptions", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEncryptionControl", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcEncryptionControl", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEncryptionControl", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpcEncryptionControl", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEndpoint", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "PrivateDnsEnabled", + "target": "PrivateDnsEnabled" + }, + { + "source": "ResourceConfigurationArn", + "target": "ResourceConfigurationArn" + }, + { + "source": "RouteTableIds", + "target": "RouteTableIds" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "ServiceName", + "target": "ServiceName" + }, + { + "source": "ServiceNetworkArn", + "target": "ServiceNetworkArn" + }, + { + "source": "ServiceRegion", + "target": "ServiceRegion" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "VpcEndpointType", + "target": "VpcEndpointType" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcEndpoint", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEndpoint", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpcEndpoints", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEndpointConnectionNotification", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "ConnectionEvents", + "target": "ConnectionEvents" + }, + { + "source": "ConnectionNotificationArn", + "target": "ConnectionNotificationArn" + }, + { + "source": "ServiceId", + "target": "ServiceId" + }, + { + "source": "VpcEndpointId", + "target": "VPCEndpointId" + } + ], + "operation": "CreateVpcEndpointConnectionNotification", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEndpointConnectionNotification", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpcEndpointConnectionNotifications", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCEndpointService", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AcceptanceRequired", + "target": "AcceptanceRequired" + }, + { + "source": "GatewayLoadBalancerArns", + "target": "GatewayLoadBalancerArns" + }, + { + "source": "NetworkLoadBalancerArns", + "target": "NetworkLoadBalancerArns" + }, + { + "source": "SupportedIpAddressTypes", + "target": "SupportedIpAddressTypes" + }, + { + "source": "SupportedRegions", + "target": "SupportedRegions" + } + ], + "operation": "CreateVpcEndpointServiceConfiguration", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCPeeringConnection", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "PeerOwnerId", + "target": "PeerOwnerId" + }, + { + "source": "PeerRegion", + "target": "PeerRegion" + }, + { + "source": "PeerVpcId", + "target": "PeerVpcId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcPeeringConnection", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPCPeeringConnection", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpcPeeringConnection", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNConcentrator", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateVpnConcentrator", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNConcentrator", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpnConcentrator", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNConnection", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "CustomerGatewayId", + "target": "CustomerGatewayId" + }, + { + "source": "PreSharedKeyStorage", + "target": "PreSharedKeyStorage" + }, + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + }, + { + "source": "Type", + "target": "Type" + }, + { + "source": "VpnConcentratorId", + "target": "VpnConcentratorId" + }, + { + "source": "VpnGatewayId", + "target": "VpnGatewayId" + } + ], + "operation": "CreateVpnConnection", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNConnection", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpnConnection", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNConnectionRoute", + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "VpnConnectionId", + "target": "VpnConnectionId" + } + ], + "operation": "CreateVpnConnectionRoute", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNConnectionRoute", + "mappings": [ + { + "source": "DestinationCidrBlock", + "target": "DestinationCidrBlock" + }, + { + "source": "VpnConnectionId", + "target": "VpnConnectionId" + } + ], + "operation": "DeleteVpnConnectionRoute", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "AmazonSideAsn", + "target": "AmazonSideAsn" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateVpnGateway", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VPNGateway", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVpnGateway", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessEndpoint", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "ApplicationDomain", + "target": "ApplicationDomain" + }, + { + "source": "AttachmentType", + "target": "AttachmentType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DomainCertificateArn", + "target": "DomainCertificateArn" + }, + { + "source": "EndpointDomainPrefix", + "target": "EndpointDomainPrefix" + }, + { + "source": "EndpointType", + "target": "EndpointType" + }, + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "VerifiedAccessGroupId", + "target": "VerifiedAccessGroupId" + } + ], + "operation": "CreateVerifiedAccessEndpoint", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessEndpoint", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [], + "operation": "DeleteVerifiedAccessEndpoint", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessGroup", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "VerifiedAccessInstanceId", + "target": "VerifiedAccessInstanceId" + } + ], + "operation": "CreateVerifiedAccessGroup", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessGroup", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [], + "operation": "DeleteVerifiedAccessGroup", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessInstance", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "CidrEndpointsCustomSubDomain", + "target": "CidrEndpointsCustomSubDomain" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "FIPSEnabled", + "target": "FipsEnabled" + } + ], + "operation": "CreateVerifiedAccessInstance", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessInstance", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [], + "operation": "DeleteVerifiedAccessInstance", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessTrustProvider", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DeviceTrustProviderType", + "target": "DeviceTrustProviderType" + }, + { + "source": "PolicyReferenceName", + "target": "PolicyReferenceName" + }, + { + "source": "TrustProviderType", + "target": "TrustProviderType" + }, + { + "source": "UserTrustProviderType", + "target": "UserTrustProviderType" + } + ], + "operation": "CreateVerifiedAccessTrustProvider", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VerifiedAccessTrustProvider", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [], + "operation": "DeleteVerifiedAccessTrustProvider", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Volume", + "ignored_inputs": [ + "ClientToken", + "DryRun" + ], + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "AvailabilityZoneId", + "target": "AvailabilityZoneId" + }, + { + "source": "Encrypted", + "target": "Encrypted" + }, + { + "source": "Iops", + "target": "Iops" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MultiAttachEnabled", + "target": "MultiAttachEnabled" + }, + { + "source": "OutpostArn", + "target": "OutpostArn" + }, + { + "source": "Size", + "target": "Size" + }, + { + "source": "SnapshotId", + "target": "SnapshotId" + }, + { + "source": "Throughput", + "target": "Throughput" + }, + { + "source": "VolumeInitializationRate", + "target": "VolumeInitializationRate" + }, + { + "source": "VolumeType", + "target": "VolumeType" + } + ], + "operation": "CreateVolume", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::Volume", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [], + "operation": "DeleteVolume", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VolumeAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Device", + "target": "Device" + }, + { + "source": "EbsCardIndex", + "target": "EbsCardIndex" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "VolumeId", + "target": "VolumeId" + } + ], + "operation": "AttachVolume", + "phase": "create", + "service": "ec2" + }, + { + "cfn_type": "AWS::EC2::VolumeAttachment", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Device", + "target": "Device" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "VolumeId", + "target": "VolumeId" + } + ], + "operation": "DetachVolume", + "phase": "delete", + "service": "ec2" + }, + { + "cfn_type": "AWS::ECR::PullThroughCacheRule", + "mappings": [ + { + "source": "credentialArn", + "target": "CredentialArn" + }, + { + "source": "customRoleArn", + "target": "CustomRoleArn" + }, + { + "source": "ecrRepositoryPrefix", + "target": "EcrRepositoryPrefix" + }, + { + "source": "upstreamRegistry", + "target": "UpstreamRegistry" + }, + { + "source": "upstreamRegistryUrl", + "target": "UpstreamRegistryUrl" + }, + { + "source": "upstreamRepositoryPrefix", + "target": "UpstreamRepositoryPrefix" + } + ], + "operation": "CreatePullThroughCacheRule", + "phase": "create", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::PullThroughCacheRule", + "mappings": [ + { + "source": "ecrRepositoryPrefix", + "target": "EcrRepositoryPrefix" + } + ], + "operation": "DeletePullThroughCacheRule", + "phase": "delete", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::PullTimeUpdateExclusion", + "mappings": [ + { + "source": "principalArn", + "target": "PrincipalArn" + } + ], + "operation": "RegisterPullTimeUpdateExclusion", + "phase": "create", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::PullTimeUpdateExclusion", + "mappings": [ + { + "source": "principalArn", + "target": "PrincipalArn" + } + ], + "operation": "DeregisterPullTimeUpdateExclusion", + "phase": "delete", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::RegistryPolicy", + "mappings": [ + { + "source": "policyText", + "target": "PolicyText" + } + ], + "operation": "PutRegistryPolicy", + "phase": "create", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::RegistryPolicy", + "mappings": [], + "operation": "DeleteRegistryPolicy", + "phase": "delete", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::RegistryScanningConfiguration", + "mappings": [ + { + "source": "scanType", + "target": "ScanType" + } + ], + "operation": "PutRegistryScanningConfiguration", + "phase": "create", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::Repository", + "mappings": [ + { + "source": "imageTagMutability", + "target": "ImageTagMutability" + }, + { + "source": "repositoryName", + "target": "RepositoryName" + } + ], + "operation": "CreateRepository", + "phase": "create", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::Repository", + "mappings": [ + { + "source": "repositoryName", + "target": "RepositoryName" + } + ], + "operation": "DeleteRepository", + "phase": "delete", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::RepositoryCreationTemplate", + "mappings": [ + { + "source": "appliedFor", + "target": "AppliedFor" + }, + { + "source": "customRoleArn", + "target": "CustomRoleArn" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "imageTagMutability", + "target": "ImageTagMutability" + }, + { + "source": "lifecyclePolicy", + "target": "LifecyclePolicy" + }, + { + "source": "prefix", + "target": "Prefix" + }, + { + "source": "repositoryPolicy", + "target": "RepositoryPolicy" + } + ], + "operation": "CreateRepositoryCreationTemplate", + "phase": "create", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::RepositoryCreationTemplate", + "mappings": [ + { + "source": "prefix", + "target": "Prefix" + } + ], + "operation": "DeleteRepositoryCreationTemplate", + "phase": "delete", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECR::SigningConfiguration", + "mappings": [], + "operation": "DeleteSigningConfiguration", + "phase": "delete", + "service": "ecr" + }, + { + "cfn_type": "AWS::ECS::CapacityProvider", + "mappings": [ + { + "source": "cluster", + "target": "ClusterName" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateCapacityProvider", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::CapacityProvider", + "mappings": [ + { + "source": "cluster", + "target": "ClusterName" + } + ], + "operation": "DeleteCapacityProvider", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::Cluster", + "mappings": [ + { + "source": "capacityProviders", + "target": "CapacityProviders" + }, + { + "source": "clusterName", + "target": "ClusterName" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::Cluster", + "mappings": [ + { + "source": "cluster", + "target": "ClusterName" + } + ], + "operation": "DeleteCluster", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::ClusterCapacityProviderAssociations", + "mappings": [ + { + "source": "capacityProviders", + "target": "CapacityProviders" + }, + { + "source": "cluster", + "target": "Cluster" + } + ], + "operation": "PutClusterCapacityProviders", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::Daemon", + "mappings": [ + { + "source": "capacityProviderArns", + "target": "CapacityProviderArns" + }, + { + "source": "clusterArn", + "target": "ClusterArn" + }, + { + "source": "daemonName", + "target": "DaemonName" + }, + { + "source": "daemonTaskDefinitionArn", + "target": "DaemonTaskDefinitionArn" + }, + { + "source": "enableECSManagedTags", + "target": "EnableECSManagedTags" + }, + { + "source": "enableExecuteCommand", + "target": "EnableExecuteCommand" + }, + { + "source": "propagateTags", + "target": "PropagateTags" + } + ], + "operation": "CreateDaemon", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::Daemon", + "mappings": [], + "operation": "DeleteDaemon", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::DaemonTaskDefinition", + "mappings": [ + { + "source": "cpu", + "target": "Cpu" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "family", + "target": "Family" + }, + { + "source": "ipcMode", + "target": "IpcMode" + }, + { + "source": "memory", + "target": "Memory" + }, + { + "source": "pidMode", + "target": "PidMode" + }, + { + "source": "taskRoleArn", + "target": "TaskRoleArn" + } + ], + "operation": "RegisterDaemonTaskDefinition", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::DaemonTaskDefinition", + "mappings": [], + "operation": "DeleteDaemonTaskDefinition", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::ExpressGatewayService", + "mappings": [ + { + "source": "cluster", + "target": "Cluster" + }, + { + "source": "cpu", + "target": "Cpu" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "healthCheckPath", + "target": "HealthCheckPath" + }, + { + "source": "infrastructureRoleArn", + "target": "InfrastructureRoleArn" + }, + { + "source": "memory", + "target": "Memory" + }, + { + "source": "serviceName", + "target": "ServiceName" + }, + { + "source": "taskDefinitionArn", + "target": "TaskDefinitionArn" + }, + { + "source": "taskRoleArn", + "target": "TaskRoleArn" + } + ], + "operation": "CreateExpressGatewayService", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::ExpressGatewayService", + "mappings": [], + "operation": "DeleteExpressGatewayService", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::Service", + "mappings": [ + { + "source": "availabilityZoneRebalancing", + "target": "AvailabilityZoneRebalancing" + }, + { + "source": "cluster", + "target": "Cluster" + }, + { + "source": "desiredCount", + "target": "DesiredCount" + }, + { + "source": "enableECSManagedTags", + "target": "EnableECSManagedTags" + }, + { + "source": "enableExecuteCommand", + "target": "EnableExecuteCommand" + }, + { + "source": "healthCheckGracePeriodSeconds", + "target": "HealthCheckGracePeriodSeconds" + }, + { + "source": "launchType", + "target": "LaunchType" + }, + { + "source": "platformVersion", + "target": "PlatformVersion" + }, + { + "source": "propagateTags", + "target": "PropagateTags" + }, + { + "source": "role", + "target": "Role" + }, + { + "source": "schedulingStrategy", + "target": "SchedulingStrategy" + }, + { + "source": "serviceName", + "target": "ServiceName" + }, + { + "source": "taskDefinition", + "target": "TaskDefinition" + } + ], + "operation": "CreateService", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::Service", + "mappings": [ + { + "source": "cluster", + "target": "Cluster" + }, + { + "source": "service", + "target": "ServiceName" + } + ], + "operation": "DeleteService", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::TaskDefinition", + "mappings": [ + { + "source": "cpu", + "target": "Cpu" + }, + { + "source": "enableFaultInjection", + "target": "EnableFaultInjection" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "family", + "target": "Family" + }, + { + "source": "ipcMode", + "target": "IpcMode" + }, + { + "source": "memory", + "target": "Memory" + }, + { + "source": "networkMode", + "target": "NetworkMode" + }, + { + "source": "pidMode", + "target": "PidMode" + }, + { + "source": "requiresCompatibilities", + "target": "RequiresCompatibilities" + }, + { + "source": "taskRoleArn", + "target": "TaskRoleArn" + } + ], + "operation": "RegisterTaskDefinition", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::TaskDefinition", + "mappings": [], + "operation": "DeregisterTaskDefinition", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::TaskSet", + "mappings": [ + { + "source": "cluster", + "target": "Cluster" + }, + { + "source": "externalId", + "target": "ExternalId" + }, + { + "source": "launchType", + "target": "LaunchType" + }, + { + "source": "platformVersion", + "target": "PlatformVersion" + }, + { + "source": "service", + "target": "Service" + }, + { + "source": "taskDefinition", + "target": "TaskDefinition" + } + ], + "operation": "CreateTaskSet", + "phase": "create", + "service": "ecs" + }, + { + "cfn_type": "AWS::ECS::TaskSet", + "mappings": [ + { + "source": "cluster", + "target": "Cluster" + }, + { + "source": "service", + "target": "Service" + } + ], + "operation": "DeleteTaskSet", + "phase": "delete", + "service": "ecs" + }, + { + "cfn_type": "AWS::EFS::AccessPoint", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "FileSystemId", + "target": "FileSystemId" + } + ], + "operation": "CreateAccessPoint", + "phase": "create", + "service": "efs" + }, + { + "cfn_type": "AWS::EFS::AccessPoint", + "mappings": [], + "operation": "DeleteAccessPoint", + "phase": "delete", + "service": "efs" + }, + { + "cfn_type": "AWS::EFS::FileSystem", + "ignored_inputs": [ + "CreationToken" + ], + "mappings": [ + { + "source": "AvailabilityZoneName", + "target": "AvailabilityZoneName" + }, + { + "source": "Encrypted", + "target": "Encrypted" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "PerformanceMode", + "target": "PerformanceMode" + }, + { + "source": "ProvisionedThroughputInMibps", + "target": "ProvisionedThroughputInMibps" + }, + { + "source": "ThroughputMode", + "target": "ThroughputMode" + } + ], + "operation": "CreateFileSystem", + "phase": "create", + "service": "efs" + }, + { + "cfn_type": "AWS::EFS::FileSystem", + "mappings": [], + "operation": "DeleteFileSystem", + "phase": "delete", + "service": "efs" + }, + { + "cfn_type": "AWS::EFS::MountTarget", + "mappings": [ + { + "source": "FileSystemId", + "target": "FileSystemId" + }, + { + "source": "IpAddress", + "target": "IpAddress" + }, + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "Ipv6Address", + "target": "Ipv6Address" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "SubnetId", + "target": "SubnetId" + } + ], + "operation": "CreateMountTarget", + "phase": "create", + "service": "efs" + }, + { + "cfn_type": "AWS::EFS::MountTarget", + "mappings": [], + "operation": "DeleteMountTarget", + "phase": "delete", + "service": "efs" + }, + { + "cfn_type": "AWS::EKS::AccessEntry", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "kubernetesGroups", + "target": "KubernetesGroups" + }, + { + "source": "principalArn", + "target": "PrincipalArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + }, + { + "source": "username", + "target": "Username" + } + ], + "operation": "CreateAccessEntry", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::AccessEntry", + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "principalArn", + "target": "PrincipalArn" + } + ], + "operation": "DeleteAccessEntry", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Addon", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "addonName", + "target": "AddonName" + }, + { + "source": "addonVersion", + "target": "AddonVersion" + }, + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "configurationValues", + "target": "ConfigurationValues" + }, + { + "source": "resolveConflicts", + "target": "ResolveConflicts" + }, + { + "source": "serviceAccountRoleArn", + "target": "ServiceAccountRoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAddon", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Addon", + "mappings": [ + { + "source": "addonName", + "target": "AddonName" + }, + { + "source": "clusterName", + "target": "ClusterName" + } + ], + "operation": "DeleteAddon", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Capability", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "capabilityName", + "target": "CapabilityName" + }, + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "deletePropagationPolicy", + "target": "DeletePropagationPolicy" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateCapability", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Capability", + "mappings": [ + { + "source": "capabilityName", + "target": "CapabilityName" + }, + { + "source": "clusterName", + "target": "ClusterName" + } + ], + "operation": "DeleteCapability", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Cluster", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "bootstrapSelfManagedAddons", + "target": "BootstrapSelfManagedAddons" + }, + { + "source": "deletionProtection", + "target": "DeletionProtection" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "version", + "target": "Version" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Cluster", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteCluster", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::FargateProfile", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "fargateProfileName", + "target": "FargateProfileName" + }, + { + "source": "podExecutionRoleArn", + "target": "PodExecutionRoleArn" + }, + { + "source": "subnets", + "target": "Subnets" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateFargateProfile", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::FargateProfile", + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "fargateProfileName", + "target": "FargateProfileName" + } + ], + "operation": "DeleteFargateProfile", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::IdentityProviderConfig", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "AssociateIdentityProviderConfig", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::IdentityProviderConfig", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + } + ], + "operation": "DisassociateIdentityProviderConfig", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Nodegroup", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "amiType", + "target": "AmiType" + }, + { + "source": "capacityType", + "target": "CapacityType" + }, + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "diskSize", + "target": "DiskSize" + }, + { + "source": "instanceTypes", + "target": "InstanceTypes" + }, + { + "source": "nodeRole", + "target": "NodeRole" + }, + { + "source": "nodegroupName", + "target": "NodegroupName" + }, + { + "source": "releaseVersion", + "target": "ReleaseVersion" + }, + { + "source": "subnets", + "target": "Subnets" + }, + { + "source": "version", + "target": "Version" + } + ], + "operation": "CreateNodegroup", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::Nodegroup", + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "nodegroupName", + "target": "NodegroupName" + } + ], + "operation": "DeleteNodegroup", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::PodIdentityAssociation", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "disableSessionTags", + "target": "DisableSessionTags" + }, + { + "source": "namespace", + "target": "Namespace" + }, + { + "source": "policy", + "target": "Policy" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "serviceAccount", + "target": "ServiceAccount" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetRoleArn", + "target": "TargetRoleArn" + } + ], + "operation": "CreatePodIdentityAssociation", + "phase": "create", + "service": "eks" + }, + { + "cfn_type": "AWS::EKS::PodIdentityAssociation", + "mappings": [ + { + "source": "clusterName", + "target": "ClusterName" + } + ], + "operation": "DeletePodIdentityAssociation", + "phase": "delete", + "service": "eks" + }, + { + "cfn_type": "AWS::EMR::SecurityConfiguration", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "SecurityConfiguration", + "target": "SecurityConfiguration" + } + ], + "operation": "CreateSecurityConfiguration", + "phase": "create", + "service": "emr" + }, + { + "cfn_type": "AWS::EMR::SecurityConfiguration", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteSecurityConfiguration", + "phase": "delete", + "service": "emr" + }, + { + "cfn_type": "AWS::EMR::Step", + "mappings": [ + { + "source": "JobFlowId", + "target": "JobFlowId" + } + ], + "operation": "AddJobFlowSteps", + "phase": "create", + "service": "emr" + }, + { + "cfn_type": "AWS::EMR::Studio", + "mappings": [ + { + "source": "AuthMode", + "target": "AuthMode" + }, + { + "source": "DefaultS3Location", + "target": "DefaultS3Location" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EncryptionKeyArn", + "target": "EncryptionKeyArn" + }, + { + "source": "EngineSecurityGroupId", + "target": "EngineSecurityGroupId" + }, + { + "source": "IdcInstanceArn", + "target": "IdcInstanceArn" + }, + { + "source": "IdcUserAssignment", + "target": "IdcUserAssignment" + }, + { + "source": "IdpAuthUrl", + "target": "IdpAuthUrl" + }, + { + "source": "IdpRelayStateParameterName", + "target": "IdpRelayStateParameterName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ServiceRole", + "target": "ServiceRole" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "TrustedIdentityPropagationEnabled", + "target": "TrustedIdentityPropagationEnabled" + }, + { + "source": "UserRole", + "target": "UserRole" + }, + { + "source": "VpcId", + "target": "VpcId" + }, + { + "source": "WorkspaceSecurityGroupId", + "target": "WorkspaceSecurityGroupId" + } + ], + "operation": "CreateStudio", + "phase": "create", + "service": "emr" + }, + { + "cfn_type": "AWS::EMR::Studio", + "mappings": [], + "operation": "DeleteStudio", + "phase": "delete", + "service": "emr" + }, + { + "cfn_type": "AWS::EMR::StudioSessionMapping", + "mappings": [ + { + "source": "IdentityName", + "target": "IdentityName" + }, + { + "source": "IdentityType", + "target": "IdentityType" + }, + { + "source": "SessionPolicyArn", + "target": "SessionPolicyArn" + }, + { + "source": "StudioId", + "target": "StudioId" + } + ], + "operation": "CreateStudioSessionMapping", + "phase": "create", + "service": "emr" + }, + { + "cfn_type": "AWS::EMR::StudioSessionMapping", + "mappings": [ + { + "source": "IdentityName", + "target": "IdentityName" + }, + { + "source": "IdentityType", + "target": "IdentityType" + }, + { + "source": "StudioId", + "target": "StudioId" + } + ], + "operation": "DeleteStudioSessionMapping", + "phase": "delete", + "service": "emr" + }, + { + "cfn_type": "AWS::EMRContainers::Endpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "releaseLabel", + "target": "ReleaseLabel" + }, + { + "source": "sessionIdleTimeoutInMinutes", + "target": "SessionIdleTimeoutInMinutes" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + }, + { + "source": "virtualClusterId", + "target": "VirtualClusterId" + } + ], + "operation": "CreateManagedEndpoint", + "phase": "create", + "service": "emr-containers" + }, + { + "cfn_type": "AWS::EMRContainers::Endpoint", + "mappings": [ + { + "source": "virtualClusterId", + "target": "VirtualClusterId" + } + ], + "operation": "DeleteManagedEndpoint", + "phase": "delete", + "service": "emr-containers" + }, + { + "cfn_type": "AWS::EMRContainers::SecurityConfiguration", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateSecurityConfiguration", + "phase": "create", + "service": "emr-containers" + }, + { + "cfn_type": "AWS::EMRContainers::SecurityConfiguration", + "mappings": [], + "operation": "DeleteSecurityConfiguration", + "phase": "delete", + "service": "emr-containers" + }, + { + "cfn_type": "AWS::EMRContainers::VirtualCluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "securityConfigurationId", + "target": "SecurityConfigurationId" + }, + { + "source": "sessionEnabled", + "target": "SessionEnabled" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateVirtualCluster", + "phase": "create", + "service": "emr-containers" + }, + { + "cfn_type": "AWS::EMRContainers::VirtualCluster", + "mappings": [], + "operation": "DeleteVirtualCluster", + "phase": "delete", + "service": "emr-containers" + }, + { + "cfn_type": "AWS::EMRServerless::Application", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "architecture", + "target": "Architecture" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "releaseLabel", + "target": "ReleaseLabel" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "emr-serverless" + }, + { + "cfn_type": "AWS::EMRServerless::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "emr-serverless" + }, + { + "cfn_type": "AWS::EVS::Environment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "environmentName", + "target": "EnvironmentName" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "serviceAccessSubnetId", + "target": "ServiceAccessSubnetId" + }, + { + "source": "siteId", + "target": "SiteId" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "termsAccepted", + "target": "TermsAccepted" + }, + { + "source": "vcfVersion", + "target": "VcfVersion" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "evs" + }, + { + "cfn_type": "AWS::EVS::Environment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "evs" + }, + { + "cfn_type": "AWS::ElastiCache::CacheCluster", + "mappings": [ + { + "source": "AZMode", + "target": "AZMode" + }, + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "CacheNodeType", + "target": "CacheNodeType" + }, + { + "source": "CacheParameterGroupName", + "target": "CacheParameterGroupName" + }, + { + "source": "CacheSecurityGroupNames", + "target": "CacheSecurityGroupNames" + }, + { + "source": "CacheSubnetGroupName", + "target": "CacheSubnetGroupName" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "IpDiscovery", + "target": "IpDiscovery" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "NotificationTopicArn", + "target": "NotificationTopicArn" + }, + { + "source": "NumCacheNodes", + "target": "NumCacheNodes" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "PreferredAvailabilityZone", + "target": "PreferredAvailabilityZone" + }, + { + "source": "PreferredAvailabilityZones", + "target": "PreferredAvailabilityZones" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "SnapshotArns", + "target": "SnapshotArns" + }, + { + "source": "SnapshotName", + "target": "SnapshotName" + }, + { + "source": "SnapshotRetentionLimit", + "target": "SnapshotRetentionLimit" + }, + { + "source": "SnapshotWindow", + "target": "SnapshotWindow" + }, + { + "source": "TransitEncryptionEnabled", + "target": "TransitEncryptionEnabled" + } + ], + "operation": "CreateCacheCluster", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::CacheCluster", + "mappings": [], + "operation": "DeleteCacheCluster", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::GlobalReplicationGroup", + "mappings": [ + { + "source": "GlobalReplicationGroupDescription", + "target": "GlobalReplicationGroupDescription" + }, + { + "source": "GlobalReplicationGroupIdSuffix", + "target": "GlobalReplicationGroupIdSuffix" + } + ], + "operation": "CreateGlobalReplicationGroup", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::GlobalReplicationGroup", + "mappings": [], + "operation": "DeleteGlobalReplicationGroup", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ParameterGroup", + "mappings": [ + { + "source": "CacheParameterGroupFamily", + "target": "CacheParameterGroupFamily" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateCacheParameterGroup", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ParameterGroup", + "mappings": [], + "operation": "DeleteCacheParameterGroup", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ReplicationGroup", + "mappings": [ + { + "source": "AtRestEncryptionEnabled", + "target": "AtRestEncryptionEnabled" + }, + { + "source": "AuthToken", + "target": "AuthToken" + }, + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "AutomaticFailoverEnabled", + "target": "AutomaticFailoverEnabled" + }, + { + "source": "CacheNodeType", + "target": "CacheNodeType" + }, + { + "source": "CacheParameterGroupName", + "target": "CacheParameterGroupName" + }, + { + "source": "CacheSecurityGroupNames", + "target": "CacheSecurityGroupNames" + }, + { + "source": "CacheSubnetGroupName", + "target": "CacheSubnetGroupName" + }, + { + "source": "ClusterMode", + "target": "ClusterMode" + }, + { + "source": "DataTieringEnabled", + "target": "DataTieringEnabled" + }, + { + "source": "Durability", + "target": "Durability" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "GlobalReplicationGroupId", + "target": "GlobalReplicationGroupId" + }, + { + "source": "IpDiscovery", + "target": "IpDiscovery" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MultiAZEnabled", + "target": "MultiAZEnabled" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "NotificationTopicArn", + "target": "NotificationTopicArn" + }, + { + "source": "NumCacheClusters", + "target": "NumCacheClusters" + }, + { + "source": "NumNodeGroups", + "target": "NumNodeGroups" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "PreferredCacheClusterAZs", + "target": "PreferredCacheClusterAZs" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "PrimaryClusterId", + "target": "PrimaryClusterId" + }, + { + "source": "ReplicasPerNodeGroup", + "target": "ReplicasPerNodeGroup" + }, + { + "source": "ReplicationGroupDescription", + "target": "ReplicationGroupDescription" + }, + { + "source": "ReplicationGroupId", + "target": "ReplicationGroupId" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "SnapshotArns", + "target": "SnapshotArns" + }, + { + "source": "SnapshotName", + "target": "SnapshotName" + }, + { + "source": "SnapshotRetentionLimit", + "target": "SnapshotRetentionLimit" + }, + { + "source": "SnapshotWindow", + "target": "SnapshotWindow" + }, + { + "source": "TransitEncryptionEnabled", + "target": "TransitEncryptionEnabled" + }, + { + "source": "TransitEncryptionMode", + "target": "TransitEncryptionMode" + }, + { + "source": "UserGroupIds", + "target": "UserGroupIds" + } + ], + "operation": "CreateReplicationGroup", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ReplicationGroup", + "mappings": [ + { + "source": "ReplicationGroupId", + "target": "ReplicationGroupId" + } + ], + "operation": "DeleteReplicationGroup", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ServerlessCache", + "mappings": [ + { + "source": "DailySnapshotTime", + "target": "DailySnapshotTime" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MajorEngineVersion", + "target": "MajorEngineVersion" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "ServerlessCacheName", + "target": "ServerlessCacheName" + }, + { + "source": "SnapshotArnsToRestore", + "target": "SnapshotArnsToRestore" + }, + { + "source": "SnapshotRetentionLimit", + "target": "SnapshotRetentionLimit" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "UserGroupId", + "target": "UserGroupId" + } + ], + "operation": "CreateServerlessCache", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ServerlessCache", + "mappings": [ + { + "source": "FinalSnapshotName", + "target": "FinalSnapshotName" + }, + { + "source": "ServerlessCacheName", + "target": "ServerlessCacheName" + } + ], + "operation": "DeleteServerlessCache", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ServerlessCacheSnapshot", + "mappings": [ + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "ServerlessCacheName", + "target": "ServerlessCacheName" + }, + { + "source": "ServerlessCacheSnapshotName", + "target": "ServerlessCacheSnapshotName" + } + ], + "operation": "CreateServerlessCacheSnapshot", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::ServerlessCacheSnapshot", + "mappings": [ + { + "source": "ServerlessCacheSnapshotName", + "target": "ServerlessCacheSnapshotName" + } + ], + "operation": "DeleteServerlessCacheSnapshot", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::SubnetGroup", + "mappings": [ + { + "source": "CacheSubnetGroupName", + "target": "CacheSubnetGroupName" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateCacheSubnetGroup", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::SubnetGroup", + "mappings": [ + { + "source": "CacheSubnetGroupName", + "target": "CacheSubnetGroupName" + } + ], + "operation": "DeleteCacheSubnetGroup", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::User", + "mappings": [ + { + "source": "AccessString", + "target": "AccessString" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "NoPasswordRequired", + "target": "NoPasswordRequired" + }, + { + "source": "Passwords", + "target": "Passwords" + }, + { + "source": "UserId", + "target": "UserId" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "CreateUser", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::User", + "mappings": [ + { + "source": "UserId", + "target": "UserId" + } + ], + "operation": "DeleteUser", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::UserGroup", + "mappings": [ + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "UserGroupId", + "target": "UserGroupId" + }, + { + "source": "UserIds", + "target": "UserIds" + } + ], + "operation": "CreateUserGroup", + "phase": "create", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElastiCache::UserGroup", + "mappings": [ + { + "source": "UserGroupId", + "target": "UserGroupId" + } + ], + "operation": "DeleteUserGroup", + "phase": "delete", + "service": "elasticache" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::Application", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::Application", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + } + ], + "operation": "DeleteApplication", + "phase": "delete", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::ApplicationVersion", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateApplicationVersion", + "phase": "create", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::ApplicationVersion", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + } + ], + "operation": "DeleteApplicationVersion", + "phase": "delete", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::ConfigurationTemplate", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnvironmentId", + "target": "EnvironmentId" + }, + { + "source": "PlatformArn", + "target": "PlatformArn" + }, + { + "source": "SolutionStackName", + "target": "SolutionStackName" + } + ], + "operation": "CreateConfigurationTemplate", + "phase": "create", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::ConfigurationTemplate", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + } + ], + "operation": "DeleteConfigurationTemplate", + "phase": "delete", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::Environment", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + }, + { + "source": "CNAMEPrefix", + "target": "CNAMEPrefix" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnvironmentName", + "target": "EnvironmentName" + }, + { + "source": "OperationsRole", + "target": "OperationsRole" + }, + { + "source": "PlatformArn", + "target": "PlatformArn" + }, + { + "source": "SolutionStackName", + "target": "SolutionStackName" + }, + { + "source": "TemplateName", + "target": "TemplateName" + }, + { + "source": "VersionLabel", + "target": "VersionLabel" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticBeanstalk::Environment", + "mappings": [ + { + "source": "EnvironmentName", + "target": "EnvironmentName" + } + ], + "operation": "TerminateEnvironment", + "phase": "delete", + "service": "elasticbeanstalk" + }, + { + "cfn_type": "AWS::ElasticLoadBalancing::LoadBalancer", + "mappings": [ + { + "source": "AvailabilityZones", + "target": "AvailabilityZones" + }, + { + "source": "LoadBalancerName", + "target": "LoadBalancerName" + }, + { + "source": "Scheme", + "target": "Scheme" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "Subnets", + "target": "Subnets" + } + ], + "operation": "CreateLoadBalancer", + "phase": "create", + "service": "elb" + }, + { + "cfn_type": "AWS::ElasticLoadBalancing::LoadBalancer", + "mappings": [ + { + "source": "LoadBalancerName", + "target": "LoadBalancerName" + } + ], + "operation": "DeleteLoadBalancer", + "phase": "delete", + "service": "elb" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::Listener", + "mappings": [ + { + "source": "AlpnPolicy", + "target": "AlpnPolicy" + }, + { + "source": "LoadBalancerArn", + "target": "LoadBalancerArn" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "Protocol", + "target": "Protocol" + }, + { + "source": "SslPolicy", + "target": "SslPolicy" + } + ], + "operation": "CreateListener", + "phase": "create", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::Listener", + "mappings": [], + "operation": "DeleteListener", + "phase": "delete", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::ListenerRule", + "mappings": [ + { + "source": "ListenerArn", + "target": "ListenerArn" + }, + { + "source": "Priority", + "target": "Priority" + } + ], + "operation": "CreateRule", + "phase": "create", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::LoadBalancer", + "mappings": [ + { + "source": "EnablePrefixForIpv6SourceNat", + "target": "EnablePrefixForIpv6SourceNat" + }, + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scheme", + "target": "Scheme" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "Subnets", + "target": "Subnets" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateLoadBalancer", + "phase": "create", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::TargetGroup", + "mappings": [ + { + "source": "HealthCheckEnabled", + "target": "HealthCheckEnabled" + }, + { + "source": "HealthCheckIntervalSeconds", + "target": "HealthCheckIntervalSeconds" + }, + { + "source": "HealthCheckPath", + "target": "HealthCheckPath" + }, + { + "source": "HealthCheckPort", + "target": "HealthCheckPort" + }, + { + "source": "HealthCheckProtocol", + "target": "HealthCheckProtocol" + }, + { + "source": "HealthCheckTimeoutSeconds", + "target": "HealthCheckTimeoutSeconds" + }, + { + "source": "HealthyThresholdCount", + "target": "HealthyThresholdCount" + }, + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "Protocol", + "target": "Protocol" + }, + { + "source": "ProtocolVersion", + "target": "ProtocolVersion" + }, + { + "source": "TargetControlPort", + "target": "TargetControlPort" + }, + { + "source": "TargetType", + "target": "TargetType" + }, + { + "source": "UnhealthyThresholdCount", + "target": "UnhealthyThresholdCount" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateTargetGroup", + "phase": "create", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::TargetGroup", + "mappings": [], + "operation": "DeleteTargetGroup", + "phase": "delete", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::TrustStore", + "mappings": [ + { + "source": "CaCertificatesBundleS3Bucket", + "target": "CaCertificatesBundleS3Bucket" + }, + { + "source": "CaCertificatesBundleS3Key", + "target": "CaCertificatesBundleS3Key" + }, + { + "source": "CaCertificatesBundleS3ObjectVersion", + "target": "CaCertificatesBundleS3ObjectVersion" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateTrustStore", + "phase": "create", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::TrustStore", + "mappings": [], + "operation": "DeleteTrustStore", + "phase": "delete", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::TrustStoreRevocation", + "mappings": [ + { + "source": "TrustStoreArn", + "target": "TrustStoreArn" + } + ], + "operation": "AddTrustStoreRevocations", + "phase": "create", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElasticLoadBalancingV2::TrustStoreRevocation", + "mappings": [ + { + "source": "TrustStoreArn", + "target": "TrustStoreArn" + } + ], + "operation": "RemoveTrustStoreRevocations", + "phase": "delete", + "service": "elbv2" + }, + { + "cfn_type": "AWS::ElementalInference::Dictionary", + "mappings": [ + { + "source": "entries", + "target": "Entries" + }, + { + "source": "language", + "target": "Language" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateDictionary", + "phase": "create", + "service": "elementalinference" + }, + { + "cfn_type": "AWS::ElementalInference::Dictionary", + "mappings": [], + "operation": "DeleteDictionary", + "phase": "delete", + "service": "elementalinference" + }, + { + "cfn_type": "AWS::ElementalInference::Feed", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateFeed", + "phase": "create", + "service": "elementalinference" + }, + { + "cfn_type": "AWS::ElementalInference::Feed", + "mappings": [], + "operation": "DeleteFeed", + "phase": "delete", + "service": "elementalinference" + }, + { + "cfn_type": "AWS::EntityResolution::IdMappingWorkflow", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "workflowName", + "target": "WorkflowName" + } + ], + "operation": "CreateIdMappingWorkflow", + "phase": "create", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::IdMappingWorkflow", + "mappings": [ + { + "source": "workflowName", + "target": "WorkflowName" + } + ], + "operation": "DeleteIdMappingWorkflow", + "phase": "delete", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::IdNamespace", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "idNamespaceName", + "target": "IdNamespaceName" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateIdNamespace", + "phase": "create", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::IdNamespace", + "mappings": [ + { + "source": "idNamespaceName", + "target": "IdNamespaceName" + } + ], + "operation": "DeleteIdNamespace", + "phase": "delete", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::MatchingWorkflow", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "workflowName", + "target": "WorkflowName" + } + ], + "operation": "CreateMatchingWorkflow", + "phase": "create", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::MatchingWorkflow", + "mappings": [ + { + "source": "workflowName", + "target": "WorkflowName" + } + ], + "operation": "DeleteMatchingWorkflow", + "phase": "delete", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::PolicyStatement", + "mappings": [ + { + "source": "action", + "target": "Action" + }, + { + "source": "arn", + "target": "Arn" + }, + { + "source": "condition", + "target": "Condition" + }, + { + "source": "effect", + "target": "Effect" + }, + { + "source": "principal", + "target": "Principal" + }, + { + "source": "statementId", + "target": "StatementId" + } + ], + "operation": "AddPolicyStatement", + "phase": "create", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::PolicyStatement", + "mappings": [ + { + "source": "arn", + "target": "Arn" + }, + { + "source": "statementId", + "target": "StatementId" + } + ], + "operation": "DeletePolicyStatement", + "phase": "delete", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::SchemaMapping", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "schemaName", + "target": "SchemaName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateSchemaMapping", + "phase": "create", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EntityResolution::SchemaMapping", + "mappings": [ + { + "source": "schemaName", + "target": "SchemaName" + } + ], + "operation": "DeleteSchemaMapping", + "phase": "delete", + "service": "entityresolution" + }, + { + "cfn_type": "AWS::EventSchemas::Discoverer", + "mappings": [ + { + "source": "CrossAccount", + "target": "CrossAccount" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "SourceArn", + "target": "SourceArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDiscoverer", + "phase": "create", + "service": "schemas" + }, + { + "cfn_type": "AWS::EventSchemas::Discoverer", + "mappings": [], + "operation": "DeleteDiscoverer", + "phase": "delete", + "service": "schemas" + }, + { + "cfn_type": "AWS::EventSchemas::Registry", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "RegistryName", + "target": "RegistryName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRegistry", + "phase": "create", + "service": "schemas" + }, + { + "cfn_type": "AWS::EventSchemas::Registry", + "mappings": [ + { + "source": "RegistryName", + "target": "RegistryName" + } + ], + "operation": "DeleteRegistry", + "phase": "delete", + "service": "schemas" + }, + { + "cfn_type": "AWS::EventSchemas::RegistryPolicy", + "mappings": [ + { + "source": "Policy", + "target": "Policy" + }, + { + "source": "RegistryName", + "target": "RegistryName" + }, + { + "source": "RevisionId", + "target": "RevisionId" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "schemas" + }, + { + "cfn_type": "AWS::EventSchemas::Schema", + "mappings": [ + { + "source": "Content", + "target": "Content" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "RegistryName", + "target": "RegistryName" + }, + { + "source": "SchemaName", + "target": "SchemaName" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateSchema", + "phase": "create", + "service": "schemas" + }, + { + "cfn_type": "AWS::EventSchemas::Schema", + "mappings": [ + { + "source": "RegistryName", + "target": "RegistryName" + }, + { + "source": "SchemaName", + "target": "SchemaName" + } + ], + "operation": "DeleteSchema", + "phase": "delete", + "service": "schemas" + }, + { + "cfn_type": "AWS::Events::ApiDestination", + "mappings": [ + { + "source": "ConnectionArn", + "target": "ConnectionArn" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "HttpMethod", + "target": "HttpMethod" + }, + { + "source": "InvocationEndpoint", + "target": "InvocationEndpoint" + }, + { + "source": "InvocationRateLimitPerSecond", + "target": "InvocationRateLimitPerSecond" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateApiDestination", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::ApiDestination", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteApiDestination", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Archive", + "mappings": [ + { + "source": "ArchiveName", + "target": "ArchiveName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventPattern", + "target": "EventPattern" + }, + { + "source": "KmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "RetentionDays", + "target": "RetentionDays" + } + ], + "operation": "CreateArchive", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Archive", + "mappings": [ + { + "source": "ArchiveName", + "target": "ArchiveName" + } + ], + "operation": "DeleteArchive", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Connection", + "mappings": [ + { + "source": "AuthorizationType", + "target": "AuthorizationType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "KmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConnection", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Connection", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteConnection", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Endpoint", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateEndpoint", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Endpoint", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteEndpoint", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::Events::EventBus", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventSourceName", + "target": "EventSourceName" + }, + { + "source": "KmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateEventBus", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::EventBus", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteEventBus", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::Events::EventBusPolicy", + "mappings": [ + { + "source": "Action", + "target": "Action" + }, + { + "source": "EventBusName", + "target": "EventBusName" + }, + { + "source": "Principal", + "target": "Principal" + }, + { + "source": "StatementId", + "target": "StatementId" + } + ], + "operation": "PutPermission", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::EventBusPolicy", + "mappings": [ + { + "source": "EventBusName", + "target": "EventBusName" + }, + { + "source": "StatementId", + "target": "StatementId" + } + ], + "operation": "RemovePermission", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Rule", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventBusName", + "target": "EventBusName" + }, + { + "source": "EventPattern", + "target": "EventPattern" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "ScheduleExpression", + "target": "ScheduleExpression" + }, + { + "source": "State", + "target": "State" + } + ], + "operation": "PutRule", + "phase": "create", + "service": "events" + }, + { + "cfn_type": "AWS::Events::Rule", + "mappings": [ + { + "source": "EventBusName", + "target": "EventBusName" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteRule", + "phase": "delete", + "service": "events" + }, + { + "cfn_type": "AWS::FIS::ExperimentTemplate", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateExperimentTemplate", + "phase": "create", + "service": "fis" + }, + { + "cfn_type": "AWS::FIS::ExperimentTemplate", + "mappings": [], + "operation": "DeleteExperimentTemplate", + "phase": "delete", + "service": "fis" + }, + { + "cfn_type": "AWS::FIS::TargetAccountConfiguration", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "accountId", + "target": "AccountId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "experimentTemplateId", + "target": "ExperimentTemplateId" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateTargetAccountConfiguration", + "phase": "create", + "service": "fis" + }, + { + "cfn_type": "AWS::FIS::TargetAccountConfiguration", + "mappings": [ + { + "source": "accountId", + "target": "AccountId" + }, + { + "source": "experimentTemplateId", + "target": "ExperimentTemplateId" + } + ], + "operation": "DeleteTargetAccountConfiguration", + "phase": "delete", + "service": "fis" + }, + { + "cfn_type": "AWS::FMS::NotificationChannel", + "mappings": [ + { + "source": "SnsRoleName", + "target": "SnsRoleName" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + } + ], + "operation": "PutNotificationChannel", + "phase": "create", + "service": "fms" + }, + { + "cfn_type": "AWS::FMS::NotificationChannel", + "mappings": [], + "operation": "DeleteNotificationChannel", + "phase": "delete", + "service": "fms" + }, + { + "cfn_type": "AWS::FMS::Policy", + "mappings": [ + { + "source": "DeleteAllPolicyResources", + "target": "DeleteAllPolicyResources" + } + ], + "operation": "DeletePolicy", + "phase": "delete", + "service": "fms" + }, + { + "cfn_type": "AWS::FMS::ResourceSet", + "mappings": [], + "operation": "DeleteResourceSet", + "phase": "delete", + "service": "fms" + }, + { + "cfn_type": "AWS::FSx::DataRepositoryAssociation", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "BatchImportMetaDataOnCreate", + "target": "BatchImportMetaDataOnCreate" + }, + { + "source": "DataRepositoryPath", + "target": "DataRepositoryPath" + }, + { + "source": "FileSystemId", + "target": "FileSystemId" + }, + { + "source": "FileSystemPath", + "target": "FileSystemPath" + }, + { + "source": "ImportedFileChunkSize", + "target": "ImportedFileChunkSize" + } + ], + "operation": "CreateDataRepositoryAssociation", + "phase": "create", + "service": "fsx" + }, + { + "cfn_type": "AWS::FSx::DataRepositoryAssociation", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [], + "operation": "DeleteDataRepositoryAssociation", + "phase": "delete", + "service": "fsx" + }, + { + "cfn_type": "AWS::FSx::S3AccessPointAttachment", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateAndAttachS3AccessPoint", + "phase": "create", + "service": "fsx" + }, + { + "cfn_type": "AWS::FinSpace::Environment", + "mappings": [ + { + "source": "dataBundles", + "target": "DataBundles" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "federationMode", + "target": "FederationMode" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "finspace" + }, + { + "cfn_type": "AWS::FinSpace::Environment", + "mappings": [], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "finspace" + }, + { + "cfn_type": "AWS::Forecast::Dataset", + "mappings": [ + { + "source": "DataFrequency", + "target": "DataFrequency" + }, + { + "source": "DatasetName", + "target": "DatasetName" + }, + { + "source": "DatasetType", + "target": "DatasetType" + }, + { + "source": "Domain", + "target": "Domain" + } + ], + "operation": "CreateDataset", + "phase": "create", + "service": "forecast" + }, + { + "cfn_type": "AWS::Forecast::Dataset", + "mappings": [], + "operation": "DeleteDataset", + "phase": "delete", + "service": "forecast" + }, + { + "cfn_type": "AWS::Forecast::DatasetGroup", + "mappings": [ + { + "source": "DatasetArns", + "target": "DatasetArns" + }, + { + "source": "DatasetGroupName", + "target": "DatasetGroupName" + }, + { + "source": "Domain", + "target": "Domain" + } + ], + "operation": "CreateDatasetGroup", + "phase": "create", + "service": "forecast" + }, + { + "cfn_type": "AWS::Forecast::DatasetGroup", + "mappings": [], + "operation": "DeleteDatasetGroup", + "phase": "delete", + "service": "forecast" + }, + { + "cfn_type": "AWS::FraudDetector::Detector", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "detectorId", + "target": "DetectorId" + } + ], + "operation": "PutDetector", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Detector", + "mappings": [ + { + "source": "detectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteDetector", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::EntityType", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "PutEntityType", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::EntityType", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteEntityType", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::EventType", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "PutEventType", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::EventType", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteEventType", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Label", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "PutLabel", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Label", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteLabel", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::List", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "elements", + "target": "Elements" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "variableType", + "target": "VariableType" + } + ], + "operation": "CreateList", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::List", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteList", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Outcome", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "PutOutcome", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Outcome", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteOutcome", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Variable", + "mappings": [ + { + "source": "dataSource", + "target": "DataSource" + }, + { + "source": "dataType", + "target": "DataType" + }, + { + "source": "defaultValue", + "target": "DefaultValue" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "variableType", + "target": "VariableType" + } + ], + "operation": "CreateVariable", + "phase": "create", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::FraudDetector::Variable", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteVariable", + "phase": "delete", + "service": "frauddetector" + }, + { + "cfn_type": "AWS::GameLift::Alias", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAlias", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Alias", + "mappings": [], + "operation": "DeleteAlias", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Build", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "OperatingSystem", + "target": "OperatingSystem" + }, + { + "source": "ServerSdkVersion", + "target": "ServerSdkVersion" + }, + { + "source": "Version", + "target": "Version" + } + ], + "operation": "CreateBuild", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Build", + "mappings": [], + "operation": "DeleteBuild", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::ContainerFleet", + "mappings": [ + { + "source": "BillingType", + "target": "BillingType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "FleetRoleArn", + "target": "FleetRoleArn" + }, + { + "source": "GameServerContainerGroupDefinitionName", + "target": "GameServerContainerGroupDefinitionName" + }, + { + "source": "GameServerContainerGroupsPerInstance", + "target": "GameServerContainerGroupsPerInstance" + }, + { + "source": "InstanceType", + "target": "InstanceType" + }, + { + "source": "MetricGroups", + "target": "MetricGroups" + }, + { + "source": "NewGameSessionProtectionPolicy", + "target": "NewGameSessionProtectionPolicy" + }, + { + "source": "PerInstanceContainerGroupDefinitionName", + "target": "PerInstanceContainerGroupDefinitionName" + }, + { + "source": "PlayerGatewayMode", + "target": "PlayerGatewayMode" + } + ], + "operation": "CreateContainerFleet", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::ContainerFleet", + "mappings": [], + "operation": "DeleteContainerFleet", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::ContainerGroupDefinition", + "mappings": [ + { + "source": "ContainerGroupType", + "target": "ContainerGroupType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OperatingSystem", + "target": "OperatingSystem" + }, + { + "source": "TotalMemoryLimitMebibytes", + "target": "TotalMemoryLimitMebibytes" + }, + { + "source": "TotalVcpuLimit", + "target": "TotalVcpuLimit" + }, + { + "source": "VersionDescription", + "target": "VersionDescription" + } + ], + "operation": "CreateContainerGroupDefinition", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::ContainerGroupDefinition", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteContainerGroupDefinition", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Fleet", + "mappings": [ + { + "source": "BuildId", + "target": "BuildId" + }, + { + "source": "ComputeType", + "target": "ComputeType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EC2InstanceType", + "target": "EC2InstanceType" + }, + { + "source": "FleetType", + "target": "FleetType" + }, + { + "source": "InstanceRoleArn", + "target": "InstanceRoleARN" + }, + { + "source": "InstanceRoleCredentialsProvider", + "target": "InstanceRoleCredentialsProvider" + }, + { + "source": "LogPaths", + "target": "LogPaths" + }, + { + "source": "MetricGroups", + "target": "MetricGroups" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NewGameSessionProtectionPolicy", + "target": "NewGameSessionProtectionPolicy" + }, + { + "source": "PeerVpcAwsAccountId", + "target": "PeerVpcAwsAccountId" + }, + { + "source": "PeerVpcId", + "target": "PeerVpcId" + }, + { + "source": "PlayerGatewayMode", + "target": "PlayerGatewayMode" + }, + { + "source": "ScriptId", + "target": "ScriptId" + }, + { + "source": "ServerLaunchParameters", + "target": "ServerLaunchParameters" + }, + { + "source": "ServerLaunchPath", + "target": "ServerLaunchPath" + } + ], + "operation": "CreateFleet", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Fleet", + "mappings": [], + "operation": "DeleteFleet", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::GameServerGroup", + "mappings": [ + { + "source": "BalancingStrategy", + "target": "BalancingStrategy" + }, + { + "source": "GameServerGroupName", + "target": "GameServerGroupName" + }, + { + "source": "GameServerProtectionPolicy", + "target": "GameServerProtectionPolicy" + }, + { + "source": "MaxSize", + "target": "MaxSize" + }, + { + "source": "MinSize", + "target": "MinSize" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "VpcSubnets", + "target": "VpcSubnets" + } + ], + "operation": "CreateGameServerGroup", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::GameServerGroup", + "mappings": [ + { + "source": "DeleteOption", + "target": "DeleteOption" + }, + { + "source": "GameServerGroupName", + "target": "GameServerGroupName" + } + ], + "operation": "DeleteGameServerGroup", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::GameSessionQueue", + "mappings": [ + { + "source": "CustomEventData", + "target": "CustomEventData" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NotificationTarget", + "target": "NotificationTarget" + }, + { + "source": "TimeoutInSeconds", + "target": "TimeoutInSeconds" + } + ], + "operation": "CreateGameSessionQueue", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::GameSessionQueue", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteGameSessionQueue", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Location", + "mappings": [ + { + "source": "LocationName", + "target": "LocationName" + } + ], + "operation": "CreateLocation", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Location", + "mappings": [ + { + "source": "LocationName", + "target": "LocationName" + } + ], + "operation": "DeleteLocation", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::MatchmakingConfiguration", + "mappings": [ + { + "source": "AcceptanceRequired", + "target": "AcceptanceRequired" + }, + { + "source": "AcceptanceTimeoutSeconds", + "target": "AcceptanceTimeoutSeconds" + }, + { + "source": "AdditionalPlayerCount", + "target": "AdditionalPlayerCount" + }, + { + "source": "BackfillMode", + "target": "BackfillMode" + }, + { + "source": "CustomEventData", + "target": "CustomEventData" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "FlexMatchMode", + "target": "FlexMatchMode" + }, + { + "source": "GameSessionData", + "target": "GameSessionData" + }, + { + "source": "GameSessionQueueArns", + "target": "GameSessionQueueArns" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NotificationTarget", + "target": "NotificationTarget" + }, + { + "source": "RequestTimeoutSeconds", + "target": "RequestTimeoutSeconds" + }, + { + "source": "RuleSetName", + "target": "RuleSetName" + } + ], + "operation": "CreateMatchmakingConfiguration", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::MatchmakingConfiguration", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteMatchmakingConfiguration", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::MatchmakingRuleSet", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "RuleSetBody", + "target": "RuleSetBody" + } + ], + "operation": "CreateMatchmakingRuleSet", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::MatchmakingRuleSet", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteMatchmakingRuleSet", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Script", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "NodeJsVersion", + "target": "NodeJsVersion" + }, + { + "source": "Version", + "target": "Version" + } + ], + "operation": "CreateScript", + "phase": "create", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLift::Script", + "mappings": [], + "operation": "DeleteScript", + "phase": "delete", + "service": "gamelift" + }, + { + "cfn_type": "AWS::GameLiftStreams::Application", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ApplicationLogOutputUri", + "target": "ApplicationLogOutputUri" + }, + { + "source": "ApplicationLogPaths", + "target": "ApplicationLogPaths" + }, + { + "source": "ApplicationSourceUri", + "target": "ApplicationSourceUri" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "ExecutablePath", + "target": "ExecutablePath" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "gameliftstreams" + }, + { + "cfn_type": "AWS::GameLiftStreams::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "gameliftstreams" + }, + { + "cfn_type": "AWS::GameLiftStreams::StreamGroup", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "StreamClass", + "target": "StreamClass" + } + ], + "operation": "CreateStreamGroup", + "phase": "create", + "service": "gameliftstreams" + }, + { + "cfn_type": "AWS::GameLiftStreams::StreamGroup", + "mappings": [], + "operation": "DeleteStreamGroup", + "phase": "delete", + "service": "gameliftstreams" + }, + { + "cfn_type": "AWS::GlobalAccelerator::Accelerator", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "IpAddresses", + "target": "IpAddresses" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAccelerator", + "phase": "create", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::Accelerator", + "mappings": [], + "operation": "DeleteAccelerator", + "phase": "delete", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::CrossAccountAttachment", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Principals", + "target": "Principals" + } + ], + "operation": "CreateCrossAccountAttachment", + "phase": "create", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::CrossAccountAttachment", + "mappings": [], + "operation": "DeleteCrossAccountAttachment", + "phase": "delete", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::EndpointGroup", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "EndpointGroupRegion", + "target": "EndpointGroupRegion" + }, + { + "source": "HealthCheckIntervalSeconds", + "target": "HealthCheckIntervalSeconds" + }, + { + "source": "HealthCheckPath", + "target": "HealthCheckPath" + }, + { + "source": "HealthCheckPort", + "target": "HealthCheckPort" + }, + { + "source": "HealthCheckProtocol", + "target": "HealthCheckProtocol" + }, + { + "source": "ListenerArn", + "target": "ListenerArn" + }, + { + "source": "ThresholdCount", + "target": "ThresholdCount" + }, + { + "source": "TrafficDialPercentage", + "target": "TrafficDialPercentage" + } + ], + "operation": "CreateEndpointGroup", + "phase": "create", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::EndpointGroup", + "mappings": [], + "operation": "DeleteEndpointGroup", + "phase": "delete", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::Listener", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcceleratorArn", + "target": "AcceleratorArn" + }, + { + "source": "ClientAffinity", + "target": "ClientAffinity" + }, + { + "source": "Protocol", + "target": "Protocol" + } + ], + "operation": "CreateListener", + "phase": "create", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::GlobalAccelerator::Listener", + "mappings": [], + "operation": "DeleteListener", + "phase": "delete", + "service": "globalaccelerator" + }, + { + "cfn_type": "AWS::Glue::Blueprint", + "mappings": [ + { + "source": "BlueprintLocation", + "target": "BlueprintLocation" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateBlueprint", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Blueprint", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteBlueprint", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Catalog", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCatalog", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Catalog", + "mappings": [], + "operation": "DeleteCatalog", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Classifier", + "mappings": [], + "operation": "DeleteClassifier", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Crawler", + "mappings": [ + { + "source": "Classifiers", + "target": "Classifiers" + }, + { + "source": "Configuration", + "target": "Configuration" + }, + { + "source": "CrawlerSecurityConfiguration", + "target": "CrawlerSecurityConfiguration" + }, + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "TablePrefix", + "target": "TablePrefix" + } + ], + "operation": "CreateCrawler", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Crawler", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteCrawler", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::CustomEntityType", + "mappings": [ + { + "source": "ContextWords", + "target": "ContextWords" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RegexString", + "target": "RegexString" + } + ], + "operation": "CreateCustomEntityType", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::CustomEntityType", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteCustomEntityType", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::DataCatalogEncryptionSettings", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + } + ], + "operation": "PutDataCatalogEncryptionSettings", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::DataQualityRuleset", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Ruleset", + "target": "Ruleset" + } + ], + "operation": "CreateDataQualityRuleset", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::DataQualityRuleset", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteDataQualityRuleset", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Database", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + } + ], + "operation": "CreateDatabase", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Database", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + }, + { + "source": "Name", + "target": "DatabaseName" + } + ], + "operation": "DeleteDatabase", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::IdentityCenterConfiguration", + "mappings": [ + { + "source": "InstanceArn", + "target": "InstanceArn" + }, + { + "source": "Scopes", + "target": "Scopes" + }, + { + "source": "UserBackgroundSessionsEnabled", + "target": "UserBackgroundSessionsEnabled" + } + ], + "operation": "CreateGlueIdentityCenterConfiguration", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::IdentityCenterConfiguration", + "mappings": [], + "operation": "DeleteGlueIdentityCenterConfiguration", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Integration", + "mappings": [ + { + "source": "DataFilter", + "target": "DataFilter" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IntegrationName", + "target": "IntegrationName" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "SourceArn", + "target": "SourceArn" + }, + { + "source": "TargetArn", + "target": "TargetArn" + } + ], + "operation": "CreateIntegration", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Integration", + "mappings": [], + "operation": "DeleteIntegration", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::IntegrationResourceProperty", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "CreateIntegrationResourceProperty", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::IntegrationResourceProperty", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteIntegrationResourceProperty", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Job", + "mappings": [ + { + "source": "AllocatedCapacity", + "target": "AllocatedCapacity" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "ExecutionClass", + "target": "ExecutionClass" + }, + { + "source": "GlueVersion", + "target": "GlueVersion" + }, + { + "source": "JobMode", + "target": "JobMode" + }, + { + "source": "JobRunQueuingEnabled", + "target": "JobRunQueuingEnabled" + }, + { + "source": "LogUri", + "target": "LogUri" + }, + { + "source": "MaintenanceWindow", + "target": "MaintenanceWindow" + }, + { + "source": "MaxCapacity", + "target": "MaxCapacity" + }, + { + "source": "MaxRetries", + "target": "MaxRetries" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NumberOfWorkers", + "target": "NumberOfWorkers" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "SecurityConfiguration", + "target": "SecurityConfiguration" + }, + { + "source": "Timeout", + "target": "Timeout" + }, + { + "source": "WorkerType", + "target": "WorkerType" + } + ], + "operation": "CreateJob", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Job", + "mappings": [], + "operation": "DeleteJob", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::MLTransform", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GlueVersion", + "target": "GlueVersion" + }, + { + "source": "MaxCapacity", + "target": "MaxCapacity" + }, + { + "source": "MaxRetries", + "target": "MaxRetries" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NumberOfWorkers", + "target": "NumberOfWorkers" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "Timeout", + "target": "Timeout" + }, + { + "source": "WorkerType", + "target": "WorkerType" + } + ], + "operation": "CreateMLTransform", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::MLTransform", + "mappings": [], + "operation": "DeleteMLTransform", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Registry", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRegistry", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Registry", + "mappings": [], + "operation": "DeleteRegistry", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Schema", + "mappings": [ + { + "source": "Compatibility", + "target": "Compatibility" + }, + { + "source": "DataFormat", + "target": "DataFormat" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "SchemaDefinition", + "target": "SchemaDefinition" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSchema", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Schema", + "mappings": [], + "operation": "DeleteSchema", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::SchemaVersion", + "mappings": [ + { + "source": "SchemaDefinition", + "target": "SchemaDefinition" + } + ], + "operation": "RegisterSchemaVersion", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::SchemaVersion", + "mappings": [], + "operation": "DeleteSchemaVersions", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::SchemaVersionMetadata", + "mappings": [ + { + "source": "SchemaVersionId", + "target": "SchemaVersionId" + } + ], + "operation": "PutSchemaVersionMetadata", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::SchemaVersionMetadata", + "mappings": [ + { + "source": "SchemaVersionId", + "target": "SchemaVersionId" + } + ], + "operation": "RemoveSchemaVersionMetadata", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::SecurityConfiguration", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateSecurityConfiguration", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::SecurityConfiguration", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteSecurityConfiguration", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::TableOptimizer", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + }, + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "TableName", + "target": "TableName" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateTableOptimizer", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::TableOptimizer", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + }, + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "TableName", + "target": "TableName" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "DeleteTableOptimizer", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Trigger", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Schedule", + "target": "Schedule" + }, + { + "source": "StartOnCreation", + "target": "StartOnCreation" + }, + { + "source": "Type", + "target": "Type" + }, + { + "source": "WorkflowName", + "target": "WorkflowName" + } + ], + "operation": "CreateTrigger", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Trigger", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteTrigger", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::UsageProfile", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateUsageProfile", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::UsageProfile", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteUsageProfile", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::UserDefinedFunction", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + } + ], + "operation": "CreateUserDefinedFunction", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::UserDefinedFunction", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "FunctionName", + "target": "FunctionName" + } + ], + "operation": "DeleteUserDefinedFunction", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Workflow", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "MaxConcurrentRuns", + "target": "MaxConcurrentRuns" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateWorkflow", + "phase": "create", + "service": "glue" + }, + { + "cfn_type": "AWS::Glue::Workflow", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteWorkflow", + "phase": "delete", + "service": "glue" + }, + { + "cfn_type": "AWS::Grafana::Workspace", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "accountAccessType", + "target": "AccountAccessType" + }, + { + "source": "authenticationProviders", + "target": "AuthenticationProviders" + }, + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "grafanaVersion", + "target": "GrafanaVersion" + }, + { + "source": "organizationRoleName", + "target": "OrganizationRoleName" + }, + { + "source": "permissionType", + "target": "PermissionType" + }, + { + "source": "stackSetName", + "target": "StackSetName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateWorkspace", + "phase": "create", + "service": "grafana" + }, + { + "cfn_type": "AWS::Grafana::Workspace", + "mappings": [], + "operation": "DeleteWorkspace", + "phase": "delete", + "service": "grafana" + }, + { + "cfn_type": "AWS::GreengrassV2::Deployment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "deploymentName", + "target": "DeploymentName" + }, + { + "source": "parentTargetArn", + "target": "ParentTargetArn" + }, + { + "source": "targetArn", + "target": "TargetArn" + } + ], + "operation": "CreateDeployment", + "phase": "create", + "service": "greengrassv2" + }, + { + "cfn_type": "AWS::GreengrassV2::Deployment", + "mappings": [], + "operation": "DeleteDeployment", + "phase": "delete", + "service": "greengrassv2" + }, + { + "cfn_type": "AWS::GroundStation::Config", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConfig", + "phase": "create", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GroundStation::Config", + "mappings": [], + "operation": "DeleteConfig", + "phase": "delete", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GroundStation::DataflowEndpointGroup", + "mappings": [ + { + "source": "contactPostPassDurationSeconds", + "target": "ContactPostPassDurationSeconds" + }, + { + "source": "contactPrePassDurationSeconds", + "target": "ContactPrePassDurationSeconds" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDataflowEndpointGroup", + "phase": "create", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GroundStation::DataflowEndpointGroup", + "mappings": [], + "operation": "DeleteDataflowEndpointGroup", + "phase": "delete", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GroundStation::DataflowEndpointGroupV2", + "mappings": [ + { + "source": "contactPostPassDurationSeconds", + "target": "ContactPostPassDurationSeconds" + }, + { + "source": "contactPrePassDurationSeconds", + "target": "ContactPrePassDurationSeconds" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDataflowEndpointGroupV2", + "phase": "create", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GroundStation::MissionProfile", + "mappings": [ + { + "source": "contactPostPassDurationSeconds", + "target": "ContactPostPassDurationSeconds" + }, + { + "source": "contactPrePassDurationSeconds", + "target": "ContactPrePassDurationSeconds" + }, + { + "source": "minimumViableContactDurationSeconds", + "target": "MinimumViableContactDurationSeconds" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "streamsKmsRole", + "target": "StreamsKmsRole" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "telemetrySinkConfigArn", + "target": "TelemetrySinkConfigArn" + }, + { + "source": "trackingConfigArn", + "target": "TrackingConfigArn" + } + ], + "operation": "CreateMissionProfile", + "phase": "create", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GroundStation::MissionProfile", + "mappings": [], + "operation": "DeleteMissionProfile", + "phase": "delete", + "service": "groundstation" + }, + { + "cfn_type": "AWS::GuardDuty::Detector", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Enable", + "target": "Enable" + }, + { + "source": "FindingPublishingFrequency", + "target": "FindingPublishingFrequency" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDetector", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::Detector", + "mappings": [], + "operation": "DeleteDetector", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::Filter", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Action", + "target": "Action" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DetectorId", + "target": "DetectorId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Rank", + "target": "Rank" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateFilter", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::Filter", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteFilter", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::IPSet", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Activate", + "target": "Activate" + }, + { + "source": "DetectorId", + "target": "DetectorId" + }, + { + "source": "ExpectedBucketOwner", + "target": "ExpectedBucketOwner" + }, + { + "source": "Format", + "target": "Format" + }, + { + "source": "Location", + "target": "Location" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateIPSet", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::IPSet", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteIPSet", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::MalwareProtectionPlan", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Role", + "target": "Role" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateMalwareProtectionPlan", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::MalwareProtectionPlan", + "mappings": [], + "operation": "DeleteMalwareProtectionPlan", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::Member", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "CreateMembers", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::Member", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteMembers", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::PublishingDestination", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DestinationType", + "target": "DestinationType" + }, + { + "source": "DetectorId", + "target": "DetectorId" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePublishingDestination", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::PublishingDestination", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeletePublishingDestination", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::ThreatEntitySet", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Activate", + "target": "Activate" + }, + { + "source": "DetectorId", + "target": "DetectorId" + }, + { + "source": "ExpectedBucketOwner", + "target": "ExpectedBucketOwner" + }, + { + "source": "Format", + "target": "Format" + }, + { + "source": "Location", + "target": "Location" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateThreatEntitySet", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::ThreatEntitySet", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteThreatEntitySet", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::ThreatIntelSet", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Activate", + "target": "Activate" + }, + { + "source": "DetectorId", + "target": "DetectorId" + }, + { + "source": "ExpectedBucketOwner", + "target": "ExpectedBucketOwner" + }, + { + "source": "Format", + "target": "Format" + }, + { + "source": "Location", + "target": "Location" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateThreatIntelSet", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::ThreatIntelSet", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteThreatIntelSet", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::TrustedEntitySet", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Activate", + "target": "Activate" + }, + { + "source": "DetectorId", + "target": "DetectorId" + }, + { + "source": "ExpectedBucketOwner", + "target": "ExpectedBucketOwner" + }, + { + "source": "Format", + "target": "Format" + }, + { + "source": "Location", + "target": "Location" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateTrustedEntitySet", + "phase": "create", + "service": "guardduty" + }, + { + "cfn_type": "AWS::GuardDuty::TrustedEntitySet", + "mappings": [ + { + "source": "DetectorId", + "target": "DetectorId" + } + ], + "operation": "DeleteTrustedEntitySet", + "phase": "delete", + "service": "guardduty" + }, + { + "cfn_type": "AWS::HealthLake::DataTransformationProfile", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "ProfileDescription", + "target": "ProfileDescription" + }, + { + "source": "ProfileName", + "target": "ProfileName" + }, + { + "source": "SourceFormat", + "target": "SourceFormat" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDataTransformationProfile", + "phase": "create", + "service": "healthlake" + }, + { + "cfn_type": "AWS::HealthLake::DataTransformationProfile", + "mappings": [], + "operation": "DeleteDataTransformationProfile", + "phase": "delete", + "service": "healthlake" + }, + { + "cfn_type": "AWS::HealthLake::FHIRDatastore", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DatastoreName", + "target": "DatastoreName" + }, + { + "source": "DatastoreTypeVersion", + "target": "DatastoreTypeVersion" + } + ], + "operation": "CreateFHIRDatastore", + "phase": "create", + "service": "healthlake" + }, + { + "cfn_type": "AWS::HealthLake::FHIRDatastore", + "mappings": [], + "operation": "DeleteFHIRDatastore", + "phase": "delete", + "service": "healthlake" + }, + { + "cfn_type": "AWS::IAM::Group", + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "Path", + "target": "Path" + } + ], + "operation": "CreateGroup", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::Group", + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + } + ], + "operation": "DeleteGroup", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::GroupPolicy", + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "PolicyName", + "target": "PolicyName" + } + ], + "operation": "PutGroupPolicy", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::GroupPolicy", + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "PolicyName", + "target": "PolicyName" + } + ], + "operation": "DeleteGroupPolicy", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::InstanceProfile", + "mappings": [ + { + "source": "InstanceProfileName", + "target": "InstanceProfileName" + }, + { + "source": "Path", + "target": "Path" + } + ], + "operation": "CreateInstanceProfile", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::InstanceProfile", + "mappings": [ + { + "source": "InstanceProfileName", + "target": "InstanceProfileName" + } + ], + "operation": "DeleteInstanceProfile", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::ManagedPolicy", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Path", + "target": "Path" + } + ], + "operation": "CreatePolicy", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::OIDCProvider", + "mappings": [ + { + "source": "ClientIDList", + "target": "ClientIdList" + }, + { + "source": "ThumbprintList", + "target": "ThumbprintList" + }, + { + "source": "Url", + "target": "Url" + } + ], + "operation": "CreateOpenIDConnectProvider", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::Role", + "mappings": [ + { + "source": "AssumeRolePolicyDocument", + "target": "AssumeRolePolicyDocument" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "MaxSessionDuration", + "target": "MaxSessionDuration" + }, + { + "source": "Path", + "target": "Path" + }, + { + "source": "PermissionsBoundary", + "target": "PermissionsBoundary" + }, + { + "source": "RoleName", + "target": "RoleName" + } + ], + "operation": "CreateRole", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::Role", + "mappings": [ + { + "source": "RoleName", + "target": "RoleName" + } + ], + "operation": "DeleteRole", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::RolePolicy", + "mappings": [ + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "PolicyName", + "target": "PolicyName" + }, + { + "source": "RoleName", + "target": "RoleName" + } + ], + "operation": "PutRolePolicy", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::RolePolicy", + "mappings": [ + { + "source": "PolicyName", + "target": "PolicyName" + }, + { + "source": "RoleName", + "target": "RoleName" + } + ], + "operation": "DeleteRolePolicy", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::SAMLProvider", + "mappings": [ + { + "source": "AddPrivateKey", + "target": "AddPrivateKey" + }, + { + "source": "AssertionEncryptionMode", + "target": "AssertionEncryptionMode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SAMLMetadataDocument", + "target": "SamlMetadataDocument" + } + ], + "operation": "CreateSAMLProvider", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::SAMLProvider", + "mappings": [], + "operation": "DeleteSAMLProvider", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::ServerCertificate", + "mappings": [ + { + "source": "ServerCertificateName", + "target": "ServerCertificateName" + } + ], + "operation": "DeleteServerCertificate", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::ServiceLinkedRole", + "mappings": [ + { + "source": "AWSServiceName", + "target": "AWSServiceName" + }, + { + "source": "CustomSuffix", + "target": "CustomSuffix" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateServiceLinkedRole", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::ServiceLinkedRole", + "mappings": [], + "operation": "DeleteServiceLinkedRole", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::User", + "mappings": [ + { + "source": "Path", + "target": "Path" + }, + { + "source": "PermissionsBoundary", + "target": "PermissionsBoundary" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "CreateUser", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::User", + "mappings": [ + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "DeleteUser", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::UserPolicy", + "mappings": [ + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "PolicyName", + "target": "PolicyName" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "PutUserPolicy", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::UserPolicy", + "mappings": [ + { + "source": "PolicyName", + "target": "PolicyName" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "DeleteUserPolicy", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::VirtualMFADevice", + "mappings": [ + { + "source": "Path", + "target": "Path" + }, + { + "source": "VirtualMFADeviceName", + "target": "VirtualMfaDeviceName" + } + ], + "operation": "CreateVirtualMFADevice", + "phase": "create", + "service": "iam" + }, + { + "cfn_type": "AWS::IAM::VirtualMFADevice", + "mappings": [], + "operation": "DeleteVirtualMFADevice", + "phase": "delete", + "service": "iam" + }, + { + "cfn_type": "AWS::IVS::Channel", + "mappings": [ + { + "source": "authorized", + "target": "Authorized" + }, + { + "source": "containerFormat", + "target": "ContainerFormat" + }, + { + "source": "insecureIngest", + "target": "InsecureIngest" + }, + { + "source": "latencyMode", + "target": "LatencyMode" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "preset", + "target": "Preset" + }, + { + "source": "recordingConfigurationArn", + "target": "RecordingConfigurationArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateChannel", + "phase": "create", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::Channel", + "mappings": [], + "operation": "DeleteChannel", + "phase": "delete", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::EncoderConfiguration", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateEncoderConfiguration", + "phase": "create", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::EncoderConfiguration", + "mappings": [], + "operation": "DeleteEncoderConfiguration", + "phase": "delete", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::IngestConfiguration", + "mappings": [ + { + "source": "ingestProtocol", + "target": "IngestProtocol" + }, + { + "source": "insecureIngest", + "target": "InsecureIngest" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "stageArn", + "target": "StageArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "userId", + "target": "UserId" + } + ], + "operation": "CreateIngestConfiguration", + "phase": "create", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::IngestConfiguration", + "mappings": [], + "operation": "DeleteIngestConfiguration", + "phase": "delete", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::PlaybackKeyPair", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "publicKeyMaterial", + "target": "PublicKeyMaterial" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "ImportPlaybackKeyPair", + "phase": "create", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::PlaybackKeyPair", + "mappings": [], + "operation": "DeletePlaybackKeyPair", + "phase": "delete", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::PlaybackRestrictionPolicy", + "mappings": [ + { + "source": "allowedCountries", + "target": "AllowedCountries" + }, + { + "source": "allowedOrigins", + "target": "AllowedOrigins" + }, + { + "source": "enableStrictOriginEnforcement", + "target": "EnableStrictOriginEnforcement" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePlaybackRestrictionPolicy", + "phase": "create", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::PlaybackRestrictionPolicy", + "mappings": [], + "operation": "DeletePlaybackRestrictionPolicy", + "phase": "delete", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::PublicKey", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "publicKeyMaterial", + "target": "PublicKeyMaterial" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "ImportPublicKey", + "phase": "create", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::PublicKey", + "mappings": [], + "operation": "DeletePublicKey", + "phase": "delete", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::RecordingConfiguration", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "recordingReconnectWindowSeconds", + "target": "RecordingReconnectWindowSeconds" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateRecordingConfiguration", + "phase": "create", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::RecordingConfiguration", + "mappings": [], + "operation": "DeleteRecordingConfiguration", + "phase": "delete", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::Stage", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateStage", + "phase": "create", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::Stage", + "mappings": [], + "operation": "DeleteStage", + "phase": "delete", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::StorageConfiguration", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateStorageConfiguration", + "phase": "create", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::StorageConfiguration", + "mappings": [], + "operation": "DeleteStorageConfiguration", + "phase": "delete", + "service": "ivs-realtime" + }, + { + "cfn_type": "AWS::IVS::StreamKey", + "mappings": [ + { + "source": "channelArn", + "target": "ChannelArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateStreamKey", + "phase": "create", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVS::StreamKey", + "mappings": [], + "operation": "DeleteStreamKey", + "phase": "delete", + "service": "ivs" + }, + { + "cfn_type": "AWS::IVSChat::LoggingConfiguration", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateLoggingConfiguration", + "phase": "create", + "service": "ivschat" + }, + { + "cfn_type": "AWS::IVSChat::LoggingConfiguration", + "mappings": [], + "operation": "DeleteLoggingConfiguration", + "phase": "delete", + "service": "ivschat" + }, + { + "cfn_type": "AWS::IVSChat::Room", + "mappings": [ + { + "source": "loggingConfigurationIdentifiers", + "target": "LoggingConfigurationIdentifiers" + }, + { + "source": "maximumMessageLength", + "target": "MaximumMessageLength" + }, + { + "source": "maximumMessageRatePerSecond", + "target": "MaximumMessageRatePerSecond" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateRoom", + "phase": "create", + "service": "ivschat" + }, + { + "cfn_type": "AWS::IVSChat::Room", + "mappings": [], + "operation": "DeleteRoom", + "phase": "delete", + "service": "ivschat" + }, + { + "cfn_type": "AWS::IdentityStore::Group", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "IdentityStoreId", + "target": "IdentityStoreId" + } + ], + "operation": "CreateGroup", + "phase": "create", + "service": "identitystore" + }, + { + "cfn_type": "AWS::IdentityStore::Group", + "mappings": [ + { + "source": "IdentityStoreId", + "target": "IdentityStoreId" + } + ], + "operation": "DeleteGroup", + "phase": "delete", + "service": "identitystore" + }, + { + "cfn_type": "AWS::IdentityStore::GroupMembership", + "mappings": [ + { + "source": "GroupId", + "target": "GroupId" + }, + { + "source": "IdentityStoreId", + "target": "IdentityStoreId" + } + ], + "operation": "CreateGroupMembership", + "phase": "create", + "service": "identitystore" + }, + { + "cfn_type": "AWS::IdentityStore::GroupMembership", + "mappings": [ + { + "source": "IdentityStoreId", + "target": "IdentityStoreId" + } + ], + "operation": "DeleteGroupMembership", + "phase": "delete", + "service": "identitystore" + }, + { + "cfn_type": "AWS::ImageBuilder::Component", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "changeDescription", + "target": "ChangeDescription" + }, + { + "source": "data", + "target": "Data" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "platform", + "target": "Platform" + }, + { + "source": "supportedOsVersions", + "target": "SupportedOsVersions" + }, + { + "source": "uri", + "target": "Uri" + } + ], + "operation": "CreateComponent", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::Component", + "mappings": [], + "operation": "DeleteComponent", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::ContainerRecipe", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "containerType", + "target": "ContainerType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "dockerfileTemplateData", + "target": "DockerfileTemplateData" + }, + { + "source": "dockerfileTemplateUri", + "target": "DockerfileTemplateUri" + }, + { + "source": "imageOsVersionOverride", + "target": "ImageOsVersionOverride" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "parentImage", + "target": "ParentImage" + }, + { + "source": "platformOverride", + "target": "PlatformOverride" + }, + { + "source": "workingDirectory", + "target": "WorkingDirectory" + } + ], + "operation": "CreateContainerRecipe", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::ContainerRecipe", + "mappings": [], + "operation": "DeleteContainerRecipe", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::DistributionConfiguration", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateDistributionConfiguration", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::DistributionConfiguration", + "mappings": [], + "operation": "DeleteDistributionConfiguration", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::Image", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "containerRecipeArn", + "target": "ContainerRecipeArn" + }, + { + "source": "distributionConfigurationArn", + "target": "DistributionConfigurationArn" + }, + { + "source": "enhancedImageMetadataEnabled", + "target": "EnhancedImageMetadataEnabled" + }, + { + "source": "executionRole", + "target": "ExecutionRole" + }, + { + "source": "imageRecipeArn", + "target": "ImageRecipeArn" + }, + { + "source": "infrastructureConfigurationArn", + "target": "InfrastructureConfigurationArn" + } + ], + "operation": "CreateImage", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::Image", + "mappings": [], + "operation": "DeleteImage", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::ImagePipeline", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "containerRecipeArn", + "target": "ContainerRecipeArn" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "distributionConfigurationArn", + "target": "DistributionConfigurationArn" + }, + { + "source": "enhancedImageMetadataEnabled", + "target": "EnhancedImageMetadataEnabled" + }, + { + "source": "executionRole", + "target": "ExecutionRole" + }, + { + "source": "imageRecipeArn", + "target": "ImageRecipeArn" + }, + { + "source": "infrastructureConfigurationArn", + "target": "InfrastructureConfigurationArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "CreateImagePipeline", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::ImagePipeline", + "mappings": [], + "operation": "DeleteImagePipeline", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::ImageRecipe", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "amiWatermarks", + "target": "AmiWatermarks" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "parentImage", + "target": "ParentImage" + }, + { + "source": "workingDirectory", + "target": "WorkingDirectory" + } + ], + "operation": "CreateImageRecipe", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::ImageRecipe", + "mappings": [], + "operation": "DeleteImageRecipe", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::InfrastructureConfiguration", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "instanceProfileName", + "target": "InstanceProfileName" + }, + { + "source": "instanceTypes", + "target": "InstanceTypes" + }, + { + "source": "keyPair", + "target": "KeyPair" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "snsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "subnetId", + "target": "SubnetId" + }, + { + "source": "terminateInstanceOnFailure", + "target": "TerminateInstanceOnFailure" + } + ], + "operation": "CreateInfrastructureConfiguration", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::InfrastructureConfiguration", + "mappings": [], + "operation": "DeleteInfrastructureConfiguration", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::LifecyclePolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "executionRole", + "target": "ExecutionRole" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "resourceType", + "target": "ResourceType" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "CreateLifecyclePolicy", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::LifecyclePolicy", + "mappings": [], + "operation": "DeleteLifecyclePolicy", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::Workflow", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "changeDescription", + "target": "ChangeDescription" + }, + { + "source": "data", + "target": "Data" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + }, + { + "source": "uri", + "target": "Uri" + } + ], + "operation": "CreateWorkflow", + "phase": "create", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::ImageBuilder::Workflow", + "mappings": [], + "operation": "DeleteWorkflow", + "phase": "delete", + "service": "imagebuilder" + }, + { + "cfn_type": "AWS::Inspector::AssessmentTarget", + "mappings": [ + { + "source": "assessmentTargetName", + "target": "AssessmentTargetName" + }, + { + "source": "resourceGroupArn", + "target": "ResourceGroupArn" + } + ], + "operation": "CreateAssessmentTarget", + "phase": "create", + "service": "inspector" + }, + { + "cfn_type": "AWS::Inspector::AssessmentTarget", + "mappings": [], + "operation": "DeleteAssessmentTarget", + "phase": "delete", + "service": "inspector" + }, + { + "cfn_type": "AWS::Inspector::AssessmentTemplate", + "mappings": [ + { + "source": "assessmentTargetArn", + "target": "AssessmentTargetArn" + }, + { + "source": "assessmentTemplateName", + "target": "AssessmentTemplateName" + }, + { + "source": "durationInSeconds", + "target": "DurationInSeconds" + }, + { + "source": "rulesPackageArns", + "target": "RulesPackageArns" + } + ], + "operation": "CreateAssessmentTemplate", + "phase": "create", + "service": "inspector" + }, + { + "cfn_type": "AWS::Inspector::AssessmentTemplate", + "mappings": [], + "operation": "DeleteAssessmentTemplate", + "phase": "delete", + "service": "inspector" + }, + { + "cfn_type": "AWS::Interconnect::Connection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "bandwidth", + "target": "Bandwidth" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "environmentId", + "target": "EnvironmentId" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConnection", + "phase": "create", + "service": "interconnect" + }, + { + "cfn_type": "AWS::Interconnect::Connection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteConnection", + "phase": "delete", + "service": "interconnect" + }, + { + "cfn_type": "AWS::InternetMonitor::Monitor", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "MaxCityNetworksToMonitor", + "target": "MaxCityNetworksToMonitor" + }, + { + "source": "MonitorName", + "target": "MonitorName" + }, + { + "source": "Resources", + "target": "Resources" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TrafficPercentageToMonitor", + "target": "TrafficPercentageToMonitor" + } + ], + "operation": "CreateMonitor", + "phase": "create", + "service": "internetmonitor" + }, + { + "cfn_type": "AWS::InternetMonitor::Monitor", + "mappings": [ + { + "source": "MonitorName", + "target": "MonitorName" + } + ], + "operation": "DeleteMonitor", + "phase": "delete", + "service": "internetmonitor" + }, + { + "cfn_type": "AWS::Invoicing::InvoiceUnit", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "InvoiceReceiver", + "target": "InvoiceReceiver" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "TaxInheritanceDisabled", + "target": "TaxInheritanceDisabled" + } + ], + "operation": "CreateInvoiceUnit", + "phase": "create", + "service": "invoicing" + }, + { + "cfn_type": "AWS::Invoicing::InvoiceUnit", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [], + "operation": "DeleteInvoiceUnit", + "phase": "delete", + "service": "invoicing" + }, + { + "cfn_type": "AWS::IoT::AccountAuditConfiguration", + "mappings": [], + "operation": "DeleteAccountAuditConfiguration", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Authorizer", + "mappings": [ + { + "source": "authorizerFunctionArn", + "target": "AuthorizerFunctionArn" + }, + { + "source": "authorizerName", + "target": "AuthorizerName" + }, + { + "source": "enableCachingForHttp", + "target": "EnableCachingForHttp" + }, + { + "source": "signingDisabled", + "target": "SigningDisabled" + }, + { + "source": "status", + "target": "Status" + }, + { + "source": "tokenKeyName", + "target": "TokenKeyName" + } + ], + "operation": "CreateAuthorizer", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Authorizer", + "mappings": [ + { + "source": "authorizerName", + "target": "AuthorizerName" + } + ], + "operation": "DeleteAuthorizer", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::BillingGroup", + "mappings": [ + { + "source": "billingGroupName", + "target": "BillingGroupName" + } + ], + "operation": "CreateBillingGroup", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::BillingGroup", + "mappings": [ + { + "source": "billingGroupName", + "target": "BillingGroupName" + } + ], + "operation": "DeleteBillingGroup", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::CACertificate", + "mappings": [ + { + "source": "certificateMode", + "target": "CertificateMode" + } + ], + "operation": "RegisterCACertificate", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::CACertificate", + "mappings": [], + "operation": "DeleteCACertificate", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Certificate", + "mappings": [ + { + "source": "caCertificatePem", + "target": "CACertificatePem" + }, + { + "source": "certificatePem", + "target": "CertificatePem" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "RegisterCertificate", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Certificate", + "mappings": [], + "operation": "DeleteCertificate", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::CertificateProvider", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "accountDefaultForOperations", + "target": "AccountDefaultForOperations" + }, + { + "source": "certificateProviderName", + "target": "CertificateProviderName" + }, + { + "source": "lambdaFunctionArn", + "target": "LambdaFunctionArn" + } + ], + "operation": "CreateCertificateProvider", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::CertificateProvider", + "mappings": [ + { + "source": "certificateProviderName", + "target": "CertificateProviderName" + } + ], + "operation": "DeleteCertificateProvider", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Command", + "mappings": [ + { + "source": "commandId", + "target": "CommandId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "namespace", + "target": "Namespace" + }, + { + "source": "payloadTemplate", + "target": "PayloadTemplate" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateCommand", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Command", + "mappings": [ + { + "source": "commandId", + "target": "CommandId" + } + ], + "operation": "DeleteCommand", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::CustomMetric", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "metricName", + "target": "MetricName" + }, + { + "source": "metricType", + "target": "MetricType" + } + ], + "operation": "CreateCustomMetric", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::CustomMetric", + "mappings": [ + { + "source": "metricName", + "target": "MetricName" + } + ], + "operation": "DeleteCustomMetric", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Dimension", + "ignored_inputs": [ + "clientRequestToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "stringValues", + "target": "StringValues" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateDimension", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Dimension", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteDimension", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::DomainConfiguration", + "mappings": [ + { + "source": "applicationProtocol", + "target": "ApplicationProtocol" + }, + { + "source": "authenticationType", + "target": "AuthenticationType" + }, + { + "source": "domainConfigurationName", + "target": "DomainConfigurationName" + }, + { + "source": "domainName", + "target": "DomainName" + }, + { + "source": "serverCertificateArns", + "target": "ServerCertificateArns" + }, + { + "source": "serviceType", + "target": "ServiceType" + }, + { + "source": "validationCertificateArn", + "target": "ValidationCertificateArn" + } + ], + "operation": "CreateDomainConfiguration", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::DomainConfiguration", + "mappings": [ + { + "source": "domainConfigurationName", + "target": "DomainConfigurationName" + } + ], + "operation": "DeleteDomainConfiguration", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::FleetMetric", + "mappings": [ + { + "source": "aggregationField", + "target": "AggregationField" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "indexName", + "target": "IndexName" + }, + { + "source": "metricName", + "target": "MetricName" + }, + { + "source": "period", + "target": "Period" + }, + { + "source": "queryString", + "target": "QueryString" + }, + { + "source": "queryVersion", + "target": "QueryVersion" + }, + { + "source": "unit", + "target": "Unit" + } + ], + "operation": "CreateFleetMetric", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::FleetMetric", + "mappings": [ + { + "source": "metricName", + "target": "MetricName" + } + ], + "operation": "DeleteFleetMetric", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Job", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "destinationPackageVersions", + "target": "DestinationPackageVersions" + }, + { + "source": "document", + "target": "Document" + }, + { + "source": "documentSource", + "target": "DocumentSource" + }, + { + "source": "jobId", + "target": "JobId" + }, + { + "source": "jobTemplateArn", + "target": "JobTemplateArn" + }, + { + "source": "targetSelection", + "target": "TargetSelection" + }, + { + "source": "targets", + "target": "Targets" + } + ], + "operation": "CreateJob", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Job", + "mappings": [ + { + "source": "jobId", + "target": "JobId" + } + ], + "operation": "DeleteJob", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::JobTemplate", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "destinationPackageVersions", + "target": "DestinationPackageVersions" + }, + { + "source": "document", + "target": "Document" + }, + { + "source": "documentSource", + "target": "DocumentSource" + }, + { + "source": "jobArn", + "target": "JobArn" + }, + { + "source": "jobTemplateId", + "target": "JobTemplateId" + } + ], + "operation": "CreateJobTemplate", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::JobTemplate", + "mappings": [ + { + "source": "jobTemplateId", + "target": "JobTemplateId" + } + ], + "operation": "DeleteJobTemplate", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Logging", + "mappings": [ + { + "source": "defaultLogLevel", + "target": "DefaultLogLevel" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "SetV2LoggingOptions", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::MitigationAction", + "mappings": [ + { + "source": "actionName", + "target": "ActionName" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateMitigationAction", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::MitigationAction", + "mappings": [ + { + "source": "actionName", + "target": "ActionName" + } + ], + "operation": "DeleteMitigationAction", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Policy", + "mappings": [ + { + "source": "policyDocument", + "target": "PolicyDocument" + }, + { + "source": "policyName", + "target": "PolicyName" + } + ], + "operation": "CreatePolicy", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Policy", + "mappings": [ + { + "source": "policyName", + "target": "PolicyName" + } + ], + "operation": "DeletePolicy", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ProvisioningTemplate", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "enabled", + "target": "Enabled" + }, + { + "source": "provisioningRoleArn", + "target": "ProvisioningRoleArn" + }, + { + "source": "templateBody", + "target": "TemplateBody" + }, + { + "source": "templateName", + "target": "TemplateName" + } + ], + "operation": "CreateProvisioningTemplate", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ProvisioningTemplate", + "mappings": [ + { + "source": "templateName", + "target": "TemplateName" + } + ], + "operation": "DeleteProvisioningTemplate", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ResourceSpecificLogging", + "mappings": [ + { + "source": "targetName", + "target": "TargetName" + }, + { + "source": "targetType", + "target": "TargetType" + } + ], + "operation": "DeleteV2LoggingLevel", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::RoleAlias", + "mappings": [ + { + "source": "credentialDurationSeconds", + "target": "CredentialDurationSeconds" + }, + { + "source": "roleAlias", + "target": "RoleAlias" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateRoleAlias", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::RoleAlias", + "mappings": [ + { + "source": "roleAlias", + "target": "RoleAlias" + } + ], + "operation": "DeleteRoleAlias", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ScheduledAudit", + "mappings": [ + { + "source": "dayOfMonth", + "target": "DayOfMonth" + }, + { + "source": "dayOfWeek", + "target": "DayOfWeek" + }, + { + "source": "frequency", + "target": "Frequency" + }, + { + "source": "scheduledAuditName", + "target": "ScheduledAuditName" + }, + { + "source": "targetCheckNames", + "target": "TargetCheckNames" + } + ], + "operation": "CreateScheduledAudit", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ScheduledAudit", + "mappings": [ + { + "source": "scheduledAuditName", + "target": "ScheduledAuditName" + } + ], + "operation": "DeleteScheduledAudit", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::SecurityProfile", + "mappings": [ + { + "source": "securityProfileDescription", + "target": "SecurityProfileDescription" + }, + { + "source": "securityProfileName", + "target": "SecurityProfileName" + } + ], + "operation": "CreateSecurityProfile", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::SecurityProfile", + "mappings": [ + { + "source": "securityProfileName", + "target": "SecurityProfileName" + } + ], + "operation": "DeleteSecurityProfile", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::SoftwarePackage", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "packageName", + "target": "PackageName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePackage", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::SoftwarePackageVersion", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "packageName", + "target": "PackageName" + }, + { + "source": "recipe", + "target": "Recipe" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "versionName", + "target": "VersionName" + } + ], + "operation": "CreatePackageVersion", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::SoftwarePackageVersion", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "packageName", + "target": "PackageName" + }, + { + "source": "versionName", + "target": "VersionName" + } + ], + "operation": "DeletePackageVersion", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Thing", + "mappings": [ + { + "source": "thingName", + "target": "ThingName" + } + ], + "operation": "CreateThing", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::Thing", + "mappings": [ + { + "source": "thingName", + "target": "ThingName" + } + ], + "operation": "DeleteThing", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ThingGroup", + "mappings": [ + { + "source": "parentGroupName", + "target": "ParentGroupName" + }, + { + "source": "thingGroupName", + "target": "ThingGroupName" + } + ], + "operation": "CreateThingGroup", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ThingType", + "mappings": [ + { + "source": "thingTypeName", + "target": "ThingTypeName" + } + ], + "operation": "CreateThingType", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::ThingType", + "mappings": [ + { + "source": "thingTypeName", + "target": "ThingTypeName" + } + ], + "operation": "DeleteThingType", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::TopicRule", + "mappings": [ + { + "source": "ruleName", + "target": "RuleName" + } + ], + "operation": "CreateTopicRule", + "phase": "create", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::TopicRule", + "mappings": [ + { + "source": "ruleName", + "target": "RuleName" + } + ], + "operation": "DeleteTopicRule", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoT::TopicRuleDestination", + "mappings": [], + "operation": "DeleteTopicRuleDestination", + "phase": "delete", + "service": "iot" + }, + { + "cfn_type": "AWS::IoTFleetWise::Campaign", + "mappings": [ + { + "source": "compression", + "target": "Compression" + }, + { + "source": "dataExtraDimensions", + "target": "DataExtraDimensions" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "diagnosticsMode", + "target": "DiagnosticsMode" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "postTriggerCollectionDuration", + "target": "PostTriggerCollectionDuration" + }, + { + "source": "priority", + "target": "Priority" + }, + { + "source": "signalCatalogArn", + "target": "SignalCatalogArn" + }, + { + "source": "spoolingMode", + "target": "SpoolingMode" + }, + { + "source": "targetArn", + "target": "TargetArn" + } + ], + "operation": "CreateCampaign", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::Campaign", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteCampaign", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::DecoderManifest", + "mappings": [ + { + "source": "defaultForUnmappedSignals", + "target": "DefaultForUnmappedSignals" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "modelManifestArn", + "target": "ModelManifestArn" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateDecoderManifest", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::DecoderManifest", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteDecoderManifest", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::Fleet", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "signalCatalogArn", + "target": "SignalCatalogArn" + } + ], + "operation": "CreateFleet", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::Fleet", + "mappings": [], + "operation": "DeleteFleet", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::ModelManifest", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "nodes", + "target": "Nodes" + }, + { + "source": "signalCatalogArn", + "target": "SignalCatalogArn" + } + ], + "operation": "CreateModelManifest", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::ModelManifest", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteModelManifest", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::SignalCatalog", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateSignalCatalog", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::SignalCatalog", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteSignalCatalog", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::StateTemplate", + "mappings": [ + { + "source": "dataExtraDimensions", + "target": "DataExtraDimensions" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "metadataExtraDimensions", + "target": "MetadataExtraDimensions" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "signalCatalogArn", + "target": "SignalCatalogArn" + }, + { + "source": "stateTemplateProperties", + "target": "StateTemplateProperties" + } + ], + "operation": "CreateStateTemplate", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::StateTemplate", + "mappings": [], + "operation": "DeleteStateTemplate", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::Vehicle", + "mappings": [ + { + "source": "associationBehavior", + "target": "AssociationBehavior" + }, + { + "source": "decoderManifestArn", + "target": "DecoderManifestArn" + }, + { + "source": "modelManifestArn", + "target": "ModelManifestArn" + } + ], + "operation": "CreateVehicle", + "phase": "create", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTFleetWise::Vehicle", + "mappings": [], + "operation": "DeleteVehicle", + "phase": "delete", + "service": "iotfleetwise" + }, + { + "cfn_type": "AWS::IoTManagedIntegrations::CredentialLocker", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateCredentialLocker", + "phase": "create", + "service": "iot-managed-integrations" + }, + { + "cfn_type": "AWS::IoTManagedIntegrations::CredentialLocker", + "mappings": [], + "operation": "DeleteCredentialLocker", + "phase": "delete", + "service": "iot-managed-integrations" + }, + { + "cfn_type": "AWS::IoTManagedIntegrations::ManagedThing", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AuthenticationMaterial", + "target": "AuthenticationMaterial" + }, + { + "source": "AuthenticationMaterialType", + "target": "AuthenticationMaterialType" + }, + { + "source": "Brand", + "target": "Brand" + }, + { + "source": "Classification", + "target": "Classification" + }, + { + "source": "CredentialLockerId", + "target": "CredentialLockerId" + }, + { + "source": "Model", + "target": "Model" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Owner", + "target": "Owner" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "SerialNumber", + "target": "SerialNumber" + } + ], + "operation": "CreateManagedThing", + "phase": "create", + "service": "iot-managed-integrations" + }, + { + "cfn_type": "AWS::IoTManagedIntegrations::ManagedThing", + "mappings": [], + "operation": "DeleteManagedThing", + "phase": "delete", + "service": "iot-managed-integrations" + }, + { + "cfn_type": "AWS::IoTManagedIntegrations::ProvisioningProfile", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CaCertificate", + "target": "CaCertificate" + }, + { + "source": "ClaimCertificate", + "target": "ClaimCertificate" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ProvisioningType", + "target": "ProvisioningType" + } + ], + "operation": "CreateProvisioningProfile", + "phase": "create", + "service": "iot-managed-integrations" + }, + { + "cfn_type": "AWS::IoTManagedIntegrations::ProvisioningProfile", + "mappings": [], + "operation": "DeleteProvisioningProfile", + "phase": "delete", + "service": "iot-managed-integrations" + }, + { + "cfn_type": "AWS::IoTSiteWise::AccessPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "accessPolicyPermission", + "target": "AccessPolicyPermission" + } + ], + "operation": "CreateAccessPolicy", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::AccessPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteAccessPolicy", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Asset", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "assetDescription", + "target": "AssetDescription" + }, + { + "source": "assetExternalId", + "target": "AssetExternalId" + }, + { + "source": "assetModelId", + "target": "AssetModelId" + }, + { + "source": "assetName", + "target": "AssetName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAsset", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Asset", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteAsset", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::AssetModel", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "assetModelDescription", + "target": "AssetModelDescription" + }, + { + "source": "assetModelExternalId", + "target": "AssetModelExternalId" + }, + { + "source": "assetModelName", + "target": "AssetModelName" + }, + { + "source": "assetModelType", + "target": "AssetModelType" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAssetModel", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::AssetModel", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteAssetModel", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::ComputationModel", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "computationModelDescription", + "target": "ComputationModelDescription" + }, + { + "source": "computationModelName", + "target": "ComputationModelName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateComputationModel", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::ComputationModel", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteComputationModel", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Dashboard", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "dashboardDefinition", + "target": "DashboardDefinition" + }, + { + "source": "dashboardDescription", + "target": "DashboardDescription" + }, + { + "source": "dashboardName", + "target": "DashboardName" + }, + { + "source": "projectId", + "target": "ProjectId" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDashboard", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Dashboard", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteDashboard", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Dataset", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "datasetDescription", + "target": "DatasetDescription" + }, + { + "source": "datasetName", + "target": "DatasetName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDataset", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Dataset", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteDataset", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Gateway", + "mappings": [ + { + "source": "gatewayName", + "target": "GatewayName" + }, + { + "source": "gatewayVersion", + "target": "GatewayVersion" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateGateway", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Gateway", + "mappings": [], + "operation": "DeleteGateway", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Portal", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "notificationSenderEmail", + "target": "NotificationSenderEmail" + }, + { + "source": "portalAuthMode", + "target": "PortalAuthMode" + }, + { + "source": "portalContactEmail", + "target": "PortalContactEmail" + }, + { + "source": "portalDescription", + "target": "PortalDescription" + }, + { + "source": "portalName", + "target": "PortalName" + }, + { + "source": "portalType", + "target": "PortalType" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePortal", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Portal", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeletePortal", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Project", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "portalId", + "target": "PortalId" + }, + { + "source": "projectDescription", + "target": "ProjectDescription" + }, + { + "source": "projectName", + "target": "ProjectName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateProject", + "phase": "create", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTSiteWise::Project", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteProject", + "phase": "delete", + "service": "iotsitewise" + }, + { + "cfn_type": "AWS::IoTTwinMaker::ComponentType", + "mappings": [ + { + "source": "componentTypeId", + "target": "ComponentTypeId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "extendsFrom", + "target": "ExtendsFrom" + }, + { + "source": "isSingleton", + "target": "IsSingleton" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "CreateComponentType", + "phase": "create", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::ComponentType", + "mappings": [ + { + "source": "componentTypeId", + "target": "ComponentTypeId" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "DeleteComponentType", + "phase": "delete", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::Entity", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "entityId", + "target": "EntityId" + }, + { + "source": "entityName", + "target": "EntityName" + }, + { + "source": "parentEntityId", + "target": "ParentEntityId" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "CreateEntity", + "phase": "create", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::Entity", + "mappings": [ + { + "source": "entityId", + "target": "EntityId" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "DeleteEntity", + "phase": "delete", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::Scene", + "mappings": [ + { + "source": "capabilities", + "target": "Capabilities" + }, + { + "source": "contentLocation", + "target": "ContentLocation" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "sceneId", + "target": "SceneId" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "CreateScene", + "phase": "create", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::Scene", + "mappings": [ + { + "source": "sceneId", + "target": "SceneId" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "DeleteScene", + "phase": "delete", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::SyncJob", + "mappings": [ + { + "source": "syncRole", + "target": "SyncRole" + }, + { + "source": "syncSource", + "target": "SyncSource" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "CreateSyncJob", + "phase": "create", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::SyncJob", + "mappings": [ + { + "source": "syncSource", + "target": "SyncSource" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "DeleteSyncJob", + "phase": "delete", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::Workspace", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "role", + "target": "Role" + }, + { + "source": "s3Location", + "target": "S3Location" + }, + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "CreateWorkspace", + "phase": "create", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTTwinMaker::Workspace", + "mappings": [ + { + "source": "workspaceId", + "target": "WorkspaceId" + } + ], + "operation": "DeleteWorkspace", + "phase": "delete", + "service": "iottwinmaker" + }, + { + "cfn_type": "AWS::IoTWireless::Destination", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Expression", + "target": "Expression" + }, + { + "source": "ExpressionType", + "target": "ExpressionType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateDestination", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::Destination", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteDestination", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::DeviceProfile", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateDeviceProfile", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::DeviceProfile", + "mappings": [], + "operation": "DeleteDeviceProfile", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::FuotaTask", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "FirmwareUpdateImage", + "target": "FirmwareUpdateImage" + }, + { + "source": "FirmwareUpdateRole", + "target": "FirmwareUpdateRole" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateFuotaTask", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::FuotaTask", + "mappings": [], + "operation": "DeleteFuotaTask", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::MulticastGroup", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateMulticastGroup", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::MulticastGroup", + "mappings": [], + "operation": "DeleteMulticastGroup", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::NetworkAnalyzerConfiguration", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "WirelessDevices", + "target": "WirelessDevices" + }, + { + "source": "WirelessGateways", + "target": "WirelessGateways" + } + ], + "operation": "CreateNetworkAnalyzerConfiguration", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::NetworkAnalyzerConfiguration", + "mappings": [], + "operation": "DeleteNetworkAnalyzerConfiguration", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::PartnerAccount", + "mappings": [ + { + "source": "PartnerAccountId", + "target": "PartnerAccountId" + }, + { + "source": "PartnerType", + "target": "PartnerType" + } + ], + "operation": "DisassociateAwsAccountFromPartnerAccount", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::ServiceProfile", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateServiceProfile", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::ServiceProfile", + "mappings": [], + "operation": "DeleteServiceProfile", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::TaskDefinition", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "AutoCreateTasks", + "target": "AutoCreateTasks" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateWirelessGatewayTaskDefinition", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::TaskDefinition", + "mappings": [], + "operation": "DeleteWirelessGatewayTaskDefinition", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::WirelessDevice", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DestinationName", + "target": "DestinationName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Positioning", + "target": "Positioning" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateWirelessDevice", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::WirelessDevice", + "mappings": [], + "operation": "DeleteWirelessDevice", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::WirelessDeviceImportTask", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "DestinationName", + "target": "DestinationName" + } + ], + "operation": "StartWirelessDeviceImportTask", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::WirelessDeviceImportTask", + "mappings": [], + "operation": "DeleteWirelessDeviceImportTask", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::WirelessGateway", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateWirelessGateway", + "phase": "create", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::IoTWireless::WirelessGateway", + "mappings": [], + "operation": "DeleteWirelessGateway", + "phase": "delete", + "service": "iotwireless" + }, + { + "cfn_type": "AWS::KMS::Alias", + "mappings": [ + { + "source": "AliasName", + "target": "AliasName" + }, + { + "source": "TargetKeyId", + "target": "TargetKeyId" + } + ], + "operation": "CreateAlias", + "phase": "create", + "service": "kms" + }, + { + "cfn_type": "AWS::KMS::Alias", + "mappings": [ + { + "source": "AliasName", + "target": "AliasName" + } + ], + "operation": "DeleteAlias", + "phase": "delete", + "service": "kms" + }, + { + "cfn_type": "AWS::KMS::Key", + "mappings": [ + { + "source": "BypassPolicyLockoutSafetyCheck", + "target": "BypassPolicyLockoutSafetyCheck" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "KeySpec", + "target": "KeySpec" + }, + { + "source": "KeyUsage", + "target": "KeyUsage" + }, + { + "source": "MultiRegion", + "target": "MultiRegion" + }, + { + "source": "Origin", + "target": "Origin" + } + ], + "operation": "CreateKey", + "phase": "create", + "service": "kms" + }, + { + "cfn_type": "AWS::KafkaConnect::Connector", + "mappings": [ + { + "source": "connectorDescription", + "target": "ConnectorDescription" + }, + { + "source": "connectorName", + "target": "ConnectorName" + }, + { + "source": "kafkaConnectVersion", + "target": "KafkaConnectVersion" + }, + { + "source": "networkType", + "target": "NetworkType" + }, + { + "source": "serviceExecutionRoleArn", + "target": "ServiceExecutionRoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateConnector", + "phase": "create", + "service": "kafkaconnect" + }, + { + "cfn_type": "AWS::KafkaConnect::Connector", + "mappings": [], + "operation": "DeleteConnector", + "phase": "delete", + "service": "kafkaconnect" + }, + { + "cfn_type": "AWS::KafkaConnect::CustomPlugin", + "mappings": [ + { + "source": "contentType", + "target": "ContentType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCustomPlugin", + "phase": "create", + "service": "kafkaconnect" + }, + { + "cfn_type": "AWS::KafkaConnect::CustomPlugin", + "mappings": [], + "operation": "DeleteCustomPlugin", + "phase": "delete", + "service": "kafkaconnect" + }, + { + "cfn_type": "AWS::KafkaConnect::WorkerConfiguration", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "propertiesFileContent", + "target": "PropertiesFileContent" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateWorkerConfiguration", + "phase": "create", + "service": "kafkaconnect" + }, + { + "cfn_type": "AWS::KafkaConnect::WorkerConfiguration", + "mappings": [], + "operation": "DeleteWorkerConfiguration", + "phase": "delete", + "service": "kafkaconnect" + }, + { + "cfn_type": "AWS::Kendra::DataSource", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "IndexId", + "target": "IndexId" + }, + { + "source": "LanguageCode", + "target": "LanguageCode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Schedule", + "target": "Schedule" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateDataSource", + "phase": "create", + "service": "kendra" + }, + { + "cfn_type": "AWS::Kendra::DataSource", + "mappings": [ + { + "source": "IndexId", + "target": "IndexId" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "kendra" + }, + { + "cfn_type": "AWS::Kendra::Faq", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "FileFormat", + "target": "FileFormat" + }, + { + "source": "IndexId", + "target": "IndexId" + }, + { + "source": "LanguageCode", + "target": "LanguageCode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateFaq", + "phase": "create", + "service": "kendra" + }, + { + "cfn_type": "AWS::Kendra::Faq", + "mappings": [ + { + "source": "IndexId", + "target": "IndexId" + } + ], + "operation": "DeleteFaq", + "phase": "delete", + "service": "kendra" + }, + { + "cfn_type": "AWS::Kendra::Index", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Edition", + "target": "Edition" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "UserContextPolicy", + "target": "UserContextPolicy" + } + ], + "operation": "CreateIndex", + "phase": "create", + "service": "kendra" + }, + { + "cfn_type": "AWS::Kendra::Index", + "mappings": [], + "operation": "DeleteIndex", + "phase": "delete", + "service": "kendra" + }, + { + "cfn_type": "AWS::KendraRanking::ExecutionPlan", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateRescoreExecutionPlan", + "phase": "create", + "service": "kendra-ranking" + }, + { + "cfn_type": "AWS::KendraRanking::ExecutionPlan", + "mappings": [], + "operation": "DeleteRescoreExecutionPlan", + "phase": "delete", + "service": "kendra-ranking" + }, + { + "cfn_type": "AWS::Kinesis::ResourcePolicy", + "mappings": [ + { + "source": "ResourceARN", + "target": "ResourceArn" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "kinesis" + }, + { + "cfn_type": "AWS::Kinesis::ResourcePolicy", + "mappings": [ + { + "source": "ResourceARN", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "kinesis" + }, + { + "cfn_type": "AWS::Kinesis::Stream", + "mappings": [ + { + "source": "MaxRecordSizeInKiB", + "target": "MaxRecordSizeInKiB" + }, + { + "source": "ShardCount", + "target": "ShardCount" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "WarmThroughputMiBps", + "target": "WarmThroughputMiBps" + } + ], + "operation": "CreateStream", + "phase": "create", + "service": "kinesis" + }, + { + "cfn_type": "AWS::Kinesis::Stream", + "mappings": [], + "operation": "DeleteStream", + "phase": "delete", + "service": "kinesis" + }, + { + "cfn_type": "AWS::Kinesis::StreamConsumer", + "mappings": [ + { + "source": "ConsumerName", + "target": "ConsumerName" + }, + { + "source": "StreamARN", + "target": "StreamARN" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "RegisterStreamConsumer", + "phase": "create", + "service": "kinesis" + }, + { + "cfn_type": "AWS::Kinesis::StreamConsumer", + "mappings": [ + { + "source": "ConsumerName", + "target": "ConsumerName" + }, + { + "source": "StreamARN", + "target": "StreamARN" + } + ], + "operation": "DeregisterStreamConsumer", + "phase": "delete", + "service": "kinesis" + }, + { + "cfn_type": "AWS::KinesisAnalyticsV2::Application", + "mappings": [ + { + "source": "ApplicationDescription", + "target": "ApplicationDescription" + }, + { + "source": "ApplicationMode", + "target": "ApplicationMode" + }, + { + "source": "ApplicationName", + "target": "ApplicationName" + }, + { + "source": "RuntimeEnvironment", + "target": "RuntimeEnvironment" + }, + { + "source": "ServiceExecutionRole", + "target": "ServiceExecutionRole" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "kinesisanalyticsv2" + }, + { + "cfn_type": "AWS::KinesisAnalyticsV2::Application", + "mappings": [ + { + "source": "ApplicationName", + "target": "ApplicationName" + } + ], + "operation": "DeleteApplication", + "phase": "delete", + "service": "kinesisanalyticsv2" + }, + { + "cfn_type": "AWS::KinesisFirehose::DeliveryStream", + "mappings": [ + { + "source": "DeliveryStreamName", + "target": "DeliveryStreamName" + }, + { + "source": "DeliveryStreamType", + "target": "DeliveryStreamType" + } + ], + "operation": "CreateDeliveryStream", + "phase": "create", + "service": "firehose" + }, + { + "cfn_type": "AWS::KinesisFirehose::DeliveryStream", + "mappings": [ + { + "source": "DeliveryStreamName", + "target": "DeliveryStreamName" + } + ], + "operation": "DeleteDeliveryStream", + "phase": "delete", + "service": "firehose" + }, + { + "cfn_type": "AWS::KinesisVideo::SignalingChannel", + "mappings": [], + "operation": "DeleteSignalingChannel", + "phase": "delete", + "service": "kinesisvideo" + }, + { + "cfn_type": "AWS::KinesisVideo::Stream", + "mappings": [ + { + "source": "DataRetentionInHours", + "target": "DataRetentionInHours" + }, + { + "source": "DeviceName", + "target": "DeviceName" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MediaType", + "target": "MediaType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateStream", + "phase": "create", + "service": "kinesisvideo" + }, + { + "cfn_type": "AWS::KinesisVideo::Stream", + "mappings": [], + "operation": "DeleteStream", + "phase": "delete", + "service": "kinesisvideo" + }, + { + "cfn_type": "AWS::LakeFormation::DataCellsFilter", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "TableCatalogId", + "target": "TableCatalogId" + }, + { + "source": "TableName", + "target": "TableName" + } + ], + "operation": "DeleteDataCellsFilter", + "phase": "delete", + "service": "lakeformation" + }, + { + "cfn_type": "AWS::LakeFormation::PrincipalPermissions", + "mappings": [ + { + "source": "Permissions", + "target": "Permissions" + }, + { + "source": "PermissionsWithGrantOption", + "target": "PermissionsWithGrantOption" + } + ], + "operation": "GrantPermissions", + "phase": "create", + "service": "lakeformation" + }, + { + "cfn_type": "AWS::LakeFormation::PrincipalPermissions", + "mappings": [ + { + "source": "Permissions", + "target": "Permissions" + }, + { + "source": "PermissionsWithGrantOption", + "target": "PermissionsWithGrantOption" + } + ], + "operation": "RevokePermissions", + "phase": "delete", + "service": "lakeformation" + }, + { + "cfn_type": "AWS::LakeFormation::Tag", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + }, + { + "source": "TagKey", + "target": "TagKey" + }, + { + "source": "TagValues", + "target": "TagValues" + } + ], + "operation": "CreateLFTag", + "phase": "create", + "service": "lakeformation" + }, + { + "cfn_type": "AWS::LakeFormation::Tag", + "mappings": [ + { + "source": "CatalogId", + "target": "CatalogId" + }, + { + "source": "TagKey", + "target": "TagKey" + } + ], + "operation": "DeleteLFTag", + "phase": "delete", + "service": "lakeformation" + }, + { + "cfn_type": "AWS::Lambda::Alias", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "FunctionVersion", + "target": "FunctionVersion" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateAlias", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Alias", + "mappings": [ + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteAlias", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::CapacityProvider", + "mappings": [ + { + "source": "CapacityProviderName", + "target": "CapacityProviderName" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCapacityProvider", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::CapacityProvider", + "mappings": [ + { + "source": "CapacityProviderName", + "target": "CapacityProviderName" + } + ], + "operation": "DeleteCapacityProvider", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::CodeSigningConfig", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCodeSigningConfig", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::CodeSigningConfig", + "mappings": [], + "operation": "DeleteCodeSigningConfig", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::EventInvokeConfig", + "mappings": [ + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "MaximumEventAgeInSeconds", + "target": "MaximumEventAgeInSeconds" + }, + { + "source": "MaximumRetryAttempts", + "target": "MaximumRetryAttempts" + }, + { + "source": "Qualifier", + "target": "Qualifier" + } + ], + "operation": "PutFunctionEventInvokeConfig", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::EventInvokeConfig", + "mappings": [ + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "Qualifier", + "target": "Qualifier" + } + ], + "operation": "DeleteFunctionEventInvokeConfig", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::EventSourceMapping", + "mappings": [ + { + "source": "BatchSize", + "target": "BatchSize" + }, + { + "source": "BisectBatchOnFunctionError", + "target": "BisectBatchOnFunctionError" + }, + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "EventSourceArn", + "target": "EventSourceArn" + }, + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "FunctionResponseTypes", + "target": "FunctionResponseTypes" + }, + { + "source": "KMSKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "MaximumBatchingWindowInSeconds", + "target": "MaximumBatchingWindowInSeconds" + }, + { + "source": "MaximumRecordAgeInSeconds", + "target": "MaximumRecordAgeInSeconds" + }, + { + "source": "MaximumRetryAttempts", + "target": "MaximumRetryAttempts" + }, + { + "source": "ParallelizationFactor", + "target": "ParallelizationFactor" + }, + { + "source": "Queues", + "target": "Queues" + }, + { + "source": "StartingPosition", + "target": "StartingPosition" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Topics", + "target": "Topics" + }, + { + "source": "TumblingWindowInSeconds", + "target": "TumblingWindowInSeconds" + } + ], + "operation": "CreateEventSourceMapping", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::EventSourceMapping", + "mappings": [], + "operation": "DeleteEventSourceMapping", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Function", + "mappings": [ + { + "source": "Architectures", + "target": "Architectures" + }, + { + "source": "CodeSigningConfigArn", + "target": "CodeSigningConfigArn" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "Handler", + "target": "Handler" + }, + { + "source": "KMSKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "Layers", + "target": "Layers" + }, + { + "source": "MemorySize", + "target": "MemorySize" + }, + { + "source": "PackageType", + "target": "PackageType" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "Runtime", + "target": "Runtime" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Timeout", + "target": "Timeout" + } + ], + "operation": "CreateFunction", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Function", + "mappings": [ + { + "source": "FunctionName", + "target": "FunctionName" + } + ], + "operation": "DeleteFunction", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Function", + "ignored_inputs": [ + "FunctionName" + ], + "mappings": [ + { + "source": "Runtime", + "target": "Runtime" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "Handler", + "target": "Handler" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Timeout", + "target": "Timeout" + }, + { + "source": "MemorySize", + "target": "MemorySize" + } + ], + "operation": "UpdateFunctionConfiguration", + "phase": "update", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::LayerVersion", + "mappings": [ + { + "source": "CompatibleArchitectures", + "target": "CompatibleArchitectures" + }, + { + "source": "CompatibleRuntimes", + "target": "CompatibleRuntimes" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "LayerName", + "target": "LayerName" + }, + { + "source": "LicenseInfo", + "target": "LicenseInfo" + } + ], + "operation": "PublishLayerVersion", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::LayerVersion", + "mappings": [ + { + "source": "LayerName", + "target": "LayerName" + } + ], + "operation": "DeleteLayerVersion", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::LayerVersionPermission", + "mappings": [ + { + "source": "Action", + "target": "Action" + }, + { + "source": "OrganizationId", + "target": "OrganizationId" + }, + { + "source": "Principal", + "target": "Principal" + } + ], + "operation": "AddLayerVersionPermission", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::LayerVersionPermission", + "mappings": [], + "operation": "RemoveLayerVersionPermission", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::MicrovmImage", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "additionalOsCapabilities", + "target": "AdditionalOsCapabilities" + }, + { + "source": "baseImageArn", + "target": "BaseImageArn" + }, + { + "source": "baseImageVersion", + "target": "BaseImageVersion" + }, + { + "source": "buildRoleArn", + "target": "BuildRoleArn" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "egressNetworkConnectors", + "target": "EgressNetworkConnectors" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateMicrovmImage", + "phase": "create", + "service": "lambda-microvms" + }, + { + "cfn_type": "AWS::Lambda::MicrovmImage", + "mappings": [], + "operation": "DeleteMicrovmImage", + "phase": "delete", + "service": "lambda-microvms" + }, + { + "cfn_type": "AWS::Lambda::NetworkConnector", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "OperatorRole", + "target": "OperatorRole" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateNetworkConnector", + "phase": "create", + "service": "lambda-core" + }, + { + "cfn_type": "AWS::Lambda::NetworkConnector", + "mappings": [], + "operation": "DeleteNetworkConnector", + "phase": "delete", + "service": "lambda-core" + }, + { + "cfn_type": "AWS::Lambda::Permission", + "mappings": [ + { + "source": "Action", + "target": "Action" + }, + { + "source": "EventSourceToken", + "target": "EventSourceToken" + }, + { + "source": "FunctionName", + "target": "FunctionName" + }, + { + "source": "FunctionUrlAuthType", + "target": "FunctionUrlAuthType" + }, + { + "source": "InvokedViaFunctionUrl", + "target": "InvokedViaFunctionUrl" + }, + { + "source": "Principal", + "target": "Principal" + }, + { + "source": "PrincipalOrgID", + "target": "PrincipalOrgID" + }, + { + "source": "SourceAccount", + "target": "SourceAccount" + }, + { + "source": "SourceArn", + "target": "SourceArn" + } + ], + "operation": "AddPermission", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Permission", + "mappings": [ + { + "source": "FunctionName", + "target": "FunctionName" + } + ], + "operation": "RemovePermission", + "phase": "delete", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Url", + "mappings": [ + { + "source": "AuthType", + "target": "AuthType" + }, + { + "source": "InvokeMode", + "target": "InvokeMode" + }, + { + "source": "Qualifier", + "target": "Qualifier" + } + ], + "operation": "CreateFunctionUrlConfig", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::Lambda::Version", + "mappings": [ + { + "source": "CodeSha256", + "target": "CodeSha256" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "FunctionName", + "target": "FunctionName" + } + ], + "operation": "PublishVersion", + "phase": "create", + "service": "lambda" + }, + { + "cfn_type": "AWS::LaunchWizard::Deployment", + "mappings": [ + { + "source": "deploymentPatternName", + "target": "DeploymentPatternName" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "workloadName", + "target": "WorkloadName" + } + ], + "operation": "CreateDeployment", + "phase": "create", + "service": "launch-wizard" + }, + { + "cfn_type": "AWS::LaunchWizard::Deployment", + "mappings": [], + "operation": "DeleteDeployment", + "phase": "delete", + "service": "launch-wizard" + }, + { + "cfn_type": "AWS::Lex::Bot", + "mappings": [ + { + "source": "botType", + "target": "BotType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "idleSessionTTLInSeconds", + "target": "IdleSessionTTLInSeconds" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateBot", + "phase": "create", + "service": "lexv2-models" + }, + { + "cfn_type": "AWS::Lex::Bot", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteBot", + "phase": "delete", + "service": "lex-models" + }, + { + "cfn_type": "AWS::Lex::BotAlias", + "mappings": [ + { + "source": "botAliasName", + "target": "BotAliasName" + }, + { + "source": "botId", + "target": "BotId" + }, + { + "source": "botVersion", + "target": "BotVersion" + }, + { + "source": "description", + "target": "Description" + } + ], + "operation": "CreateBotAlias", + "phase": "create", + "service": "lexv2-models" + }, + { + "cfn_type": "AWS::Lex::BotAlias", + "mappings": [ + { + "source": "name", + "target": "BotAliasName" + } + ], + "operation": "DeleteBotAlias", + "phase": "delete", + "service": "lex-models" + }, + { + "cfn_type": "AWS::Lex::BotVersion", + "mappings": [ + { + "source": "botId", + "target": "BotId" + }, + { + "source": "description", + "target": "Description" + } + ], + "operation": "CreateBotVersion", + "phase": "create", + "service": "lexv2-models" + }, + { + "cfn_type": "AWS::Lex::BotVersion", + "mappings": [ + { + "source": "botId", + "target": "BotId" + } + ], + "operation": "DeleteBotVersion", + "phase": "delete", + "service": "lexv2-models" + }, + { + "cfn_type": "AWS::Lex::ResourcePolicy", + "mappings": [ + { + "source": "policy", + "target": "Policy" + }, + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "CreateResourcePolicy", + "phase": "create", + "service": "lexv2-models" + }, + { + "cfn_type": "AWS::Lex::ResourcePolicy", + "mappings": [ + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "lexv2-models" + }, + { + "cfn_type": "AWS::LicenseManager::Grant", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AllowedOperations", + "target": "AllowedOperations" + }, + { + "source": "GrantName", + "target": "GrantName" + }, + { + "source": "HomeRegion", + "target": "HomeRegion" + }, + { + "source": "LicenseArn", + "target": "LicenseArn" + }, + { + "source": "Principals", + "target": "Principals" + } + ], + "operation": "CreateGrant", + "phase": "create", + "service": "license-manager" + }, + { + "cfn_type": "AWS::LicenseManager::Grant", + "mappings": [], + "operation": "DeleteGrant", + "phase": "delete", + "service": "license-manager" + }, + { + "cfn_type": "AWS::LicenseManager::License", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Beneficiary", + "target": "Beneficiary" + }, + { + "source": "HomeRegion", + "target": "HomeRegion" + }, + { + "source": "LicenseName", + "target": "LicenseName" + }, + { + "source": "ProductName", + "target": "ProductName" + }, + { + "source": "ProductSKU", + "target": "ProductSKU" + } + ], + "operation": "CreateLicense", + "phase": "create", + "service": "license-manager" + }, + { + "cfn_type": "AWS::LicenseManager::License", + "mappings": [], + "operation": "DeleteLicense", + "phase": "delete", + "service": "license-manager" + }, + { + "cfn_type": "AWS::LicenseManager::LicenseAssetRuleSet", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateLicenseAssetRuleset", + "phase": "create", + "service": "license-manager" + }, + { + "cfn_type": "AWS::LicenseManager::LicenseAssetRuleSet", + "mappings": [], + "operation": "DeleteLicenseAssetRuleset", + "phase": "delete", + "service": "license-manager" + }, + { + "cfn_type": "AWS::Lightsail::Alarm", + "mappings": [ + { + "source": "alarmName", + "target": "AlarmName" + }, + { + "source": "comparisonOperator", + "target": "ComparisonOperator" + }, + { + "source": "contactProtocols", + "target": "ContactProtocols" + }, + { + "source": "datapointsToAlarm", + "target": "DatapointsToAlarm" + }, + { + "source": "evaluationPeriods", + "target": "EvaluationPeriods" + }, + { + "source": "metricName", + "target": "MetricName" + }, + { + "source": "monitoredResourceName", + "target": "MonitoredResourceName" + }, + { + "source": "notificationEnabled", + "target": "NotificationEnabled" + }, + { + "source": "notificationTriggers", + "target": "NotificationTriggers" + }, + { + "source": "threshold", + "target": "Threshold" + }, + { + "source": "treatMissingData", + "target": "TreatMissingData" + } + ], + "operation": "PutAlarm", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Alarm", + "mappings": [ + { + "source": "alarmName", + "target": "AlarmName" + } + ], + "operation": "DeleteAlarm", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Bucket", + "mappings": [ + { + "source": "bucketName", + "target": "BucketName" + }, + { + "source": "bundleId", + "target": "BundleId" + } + ], + "operation": "CreateBucket", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Bucket", + "mappings": [ + { + "source": "bucketName", + "target": "BucketName" + } + ], + "operation": "DeleteBucket", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Certificate", + "mappings": [ + { + "source": "certificateName", + "target": "CertificateName" + }, + { + "source": "domainName", + "target": "DomainName" + }, + { + "source": "subjectAlternativeNames", + "target": "SubjectAlternativeNames" + } + ], + "operation": "CreateCertificate", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Certificate", + "mappings": [ + { + "source": "certificateName", + "target": "CertificateName" + } + ], + "operation": "DeleteCertificate", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Container", + "mappings": [ + { + "source": "power", + "target": "Power" + }, + { + "source": "scale", + "target": "Scale" + }, + { + "source": "serviceName", + "target": "ServiceName" + } + ], + "operation": "CreateContainerService", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Database", + "mappings": [ + { + "source": "availabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "masterDatabaseName", + "target": "MasterDatabaseName" + }, + { + "source": "masterUserPassword", + "target": "MasterUserPassword" + }, + { + "source": "masterUsername", + "target": "MasterUsername" + }, + { + "source": "preferredBackupWindow", + "target": "PreferredBackupWindow" + }, + { + "source": "preferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "publiclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "relationalDatabaseBlueprintId", + "target": "RelationalDatabaseBlueprintId" + }, + { + "source": "relationalDatabaseBundleId", + "target": "RelationalDatabaseBundleId" + }, + { + "source": "relationalDatabaseName", + "target": "RelationalDatabaseName" + } + ], + "operation": "CreateRelationalDatabase", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Database", + "mappings": [ + { + "source": "relationalDatabaseName", + "target": "RelationalDatabaseName" + } + ], + "operation": "DeleteRelationalDatabase", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::DatabaseSnapshot", + "mappings": [ + { + "source": "relationalDatabaseName", + "target": "RelationalDatabaseName" + }, + { + "source": "relationalDatabaseSnapshotName", + "target": "RelationalDatabaseSnapshotName" + } + ], + "operation": "CreateRelationalDatabaseSnapshot", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::DatabaseSnapshot", + "mappings": [ + { + "source": "relationalDatabaseSnapshotName", + "target": "RelationalDatabaseSnapshotName" + } + ], + "operation": "DeleteRelationalDatabaseSnapshot", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Disk", + "mappings": [ + { + "source": "availabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "diskName", + "target": "DiskName" + }, + { + "source": "sizeInGb", + "target": "SizeInGb" + } + ], + "operation": "CreateDisk", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Disk", + "mappings": [ + { + "source": "diskName", + "target": "DiskName" + } + ], + "operation": "DeleteDisk", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::DiskSnapshot", + "mappings": [ + { + "source": "diskName", + "target": "DiskName" + }, + { + "source": "diskSnapshotName", + "target": "DiskSnapshotName" + } + ], + "operation": "CreateDiskSnapshot", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::DiskSnapshot", + "mappings": [ + { + "source": "diskSnapshotName", + "target": "DiskSnapshotName" + } + ], + "operation": "DeleteDiskSnapshot", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Distribution", + "mappings": [ + { + "source": "bundleId", + "target": "BundleId" + }, + { + "source": "certificateName", + "target": "CertificateName" + }, + { + "source": "distributionName", + "target": "DistributionName" + }, + { + "source": "ipAddressType", + "target": "IpAddressType" + } + ], + "operation": "CreateDistribution", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Distribution", + "mappings": [ + { + "source": "distributionName", + "target": "DistributionName" + } + ], + "operation": "DeleteDistribution", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Domain", + "mappings": [ + { + "source": "domainName", + "target": "DomainName" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Domain", + "mappings": [ + { + "source": "domainName", + "target": "DomainName" + } + ], + "operation": "DeleteDomain", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Instance", + "mappings": [ + { + "source": "availabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "blueprintId", + "target": "BlueprintId" + }, + { + "source": "bundleId", + "target": "BundleId" + }, + { + "source": "keyPairName", + "target": "KeyPairName" + }, + { + "source": "userData", + "target": "UserData" + } + ], + "operation": "CreateInstances", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::Instance", + "mappings": [ + { + "source": "instanceName", + "target": "InstanceName" + } + ], + "operation": "DeleteInstance", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::InstanceSnapshot", + "mappings": [ + { + "source": "instanceName", + "target": "InstanceName" + }, + { + "source": "instanceSnapshotName", + "target": "InstanceSnapshotName" + } + ], + "operation": "CreateInstanceSnapshot", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::InstanceSnapshot", + "mappings": [ + { + "source": "instanceSnapshotName", + "target": "InstanceSnapshotName" + } + ], + "operation": "DeleteInstanceSnapshot", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::LoadBalancer", + "mappings": [ + { + "source": "healthCheckPath", + "target": "HealthCheckPath" + }, + { + "source": "instancePort", + "target": "InstancePort" + }, + { + "source": "ipAddressType", + "target": "IpAddressType" + }, + { + "source": "loadBalancerName", + "target": "LoadBalancerName" + }, + { + "source": "tlsPolicyName", + "target": "TlsPolicyName" + } + ], + "operation": "CreateLoadBalancer", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::LoadBalancer", + "mappings": [ + { + "source": "loadBalancerName", + "target": "LoadBalancerName" + } + ], + "operation": "DeleteLoadBalancer", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::LoadBalancerTlsCertificate", + "mappings": [ + { + "source": "certificateAlternativeNames", + "target": "CertificateAlternativeNames" + }, + { + "source": "certificateDomainName", + "target": "CertificateDomainName" + }, + { + "source": "certificateName", + "target": "CertificateName" + }, + { + "source": "loadBalancerName", + "target": "LoadBalancerName" + } + ], + "operation": "CreateLoadBalancerTlsCertificate", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::LoadBalancerTlsCertificate", + "mappings": [ + { + "source": "certificateName", + "target": "CertificateName" + }, + { + "source": "loadBalancerName", + "target": "LoadBalancerName" + } + ], + "operation": "DeleteLoadBalancerTlsCertificate", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::StaticIp", + "mappings": [ + { + "source": "staticIpName", + "target": "StaticIpName" + } + ], + "operation": "AllocateStaticIp", + "phase": "create", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Lightsail::StaticIp", + "mappings": [ + { + "source": "staticIpName", + "target": "StaticIpName" + } + ], + "operation": "ReleaseStaticIp", + "phase": "delete", + "service": "lightsail" + }, + { + "cfn_type": "AWS::Location::APIKey", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "KeyName", + "target": "KeyName" + }, + { + "source": "NoExpiry", + "target": "NoExpiry" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateKey", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::APIKey", + "mappings": [ + { + "source": "ForceDelete", + "target": "ForceDelete" + }, + { + "source": "KeyName", + "target": "KeyName" + } + ], + "operation": "DeleteKey", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Location::GeofenceCollection", + "mappings": [ + { + "source": "CollectionName", + "target": "CollectionName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "PricingPlan", + "target": "PricingPlan" + }, + { + "source": "PricingPlanDataSource", + "target": "PricingPlanDataSource" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateGeofenceCollection", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::GeofenceCollection", + "mappings": [ + { + "source": "CollectionName", + "target": "CollectionName" + } + ], + "operation": "DeleteGeofenceCollection", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Location::Map", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "MapName", + "target": "MapName" + }, + { + "source": "PricingPlan", + "target": "PricingPlan" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateMap", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::Map", + "mappings": [ + { + "source": "MapName", + "target": "MapName" + } + ], + "operation": "DeleteMap", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Location::PlaceIndex", + "mappings": [ + { + "source": "DataSource", + "target": "DataSource" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IndexName", + "target": "IndexName" + }, + { + "source": "PricingPlan", + "target": "PricingPlan" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePlaceIndex", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::PlaceIndex", + "mappings": [ + { + "source": "IndexName", + "target": "IndexName" + } + ], + "operation": "DeletePlaceIndex", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Location::RouteCalculator", + "mappings": [ + { + "source": "CalculatorName", + "target": "CalculatorName" + }, + { + "source": "DataSource", + "target": "DataSource" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "PricingPlan", + "target": "PricingPlan" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRouteCalculator", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::RouteCalculator", + "mappings": [ + { + "source": "CalculatorName", + "target": "CalculatorName" + } + ], + "operation": "DeleteRouteCalculator", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Location::Tracker", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventBridgeEnabled", + "target": "EventBridgeEnabled" + }, + { + "source": "KmsKeyEnableGeospatialQueries", + "target": "KmsKeyEnableGeospatialQueries" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "PositionFiltering", + "target": "PositionFiltering" + }, + { + "source": "PricingPlan", + "target": "PricingPlan" + }, + { + "source": "PricingPlanDataSource", + "target": "PricingPlanDataSource" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TrackerName", + "target": "TrackerName" + } + ], + "operation": "CreateTracker", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::Tracker", + "mappings": [ + { + "source": "TrackerName", + "target": "TrackerName" + } + ], + "operation": "DeleteTracker", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Location::TrackerConsumer", + "mappings": [ + { + "source": "ConsumerArn", + "target": "ConsumerArn" + }, + { + "source": "TrackerName", + "target": "TrackerName" + } + ], + "operation": "AssociateTrackerConsumer", + "phase": "create", + "service": "location" + }, + { + "cfn_type": "AWS::Location::TrackerConsumer", + "mappings": [ + { + "source": "ConsumerArn", + "target": "ConsumerArn" + }, + { + "source": "TrackerName", + "target": "TrackerName" + } + ], + "operation": "DisassociateTrackerConsumer", + "phase": "delete", + "service": "location" + }, + { + "cfn_type": "AWS::Logs::AccountPolicy", + "mappings": [ + { + "source": "policyDocument", + "target": "PolicyDocument" + }, + { + "source": "policyName", + "target": "PolicyName" + }, + { + "source": "policyType", + "target": "PolicyType" + }, + { + "source": "scope", + "target": "Scope" + }, + { + "source": "selectionCriteria", + "target": "SelectionCriteria" + } + ], + "operation": "PutAccountPolicy", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::AccountPolicy", + "mappings": [ + { + "source": "policyName", + "target": "PolicyName" + }, + { + "source": "policyType", + "target": "PolicyType" + } + ], + "operation": "DeleteAccountPolicy", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Delivery", + "mappings": [ + { + "source": "deliveryDestinationArn", + "target": "DeliveryDestinationArn" + }, + { + "source": "deliverySourceName", + "target": "DeliverySourceName" + }, + { + "source": "fieldDelimiter", + "target": "FieldDelimiter" + }, + { + "source": "recordFields", + "target": "RecordFields" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDelivery", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Delivery", + "mappings": [], + "operation": "DeleteDelivery", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::DeliveryDestination", + "mappings": [ + { + "source": "deliveryDestinationType", + "target": "DeliveryDestinationType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "outputFormat", + "target": "OutputFormat" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "PutDeliveryDestination", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::DeliveryDestination", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteDeliveryDestination", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::DeliverySource", + "mappings": [ + { + "source": "logType", + "target": "LogType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "resourceArn", + "target": "ResourceArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "PutDeliverySource", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::DeliverySource", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteDeliverySource", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Destination", + "mappings": [ + { + "source": "destinationName", + "target": "DestinationName" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetArn", + "target": "TargetArn" + } + ], + "operation": "PutDestination", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Destination", + "mappings": [ + { + "source": "destinationName", + "target": "DestinationName" + } + ], + "operation": "DeleteDestination", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Integration", + "mappings": [ + { + "source": "integrationName", + "target": "IntegrationName" + }, + { + "source": "integrationType", + "target": "IntegrationType" + } + ], + "operation": "PutIntegration", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Integration", + "mappings": [ + { + "source": "integrationName", + "target": "IntegrationName" + } + ], + "operation": "DeleteIntegration", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::LogAnomalyDetector", + "mappings": [ + { + "source": "anomalyVisibilityTime", + "target": "AnomalyVisibilityTime" + }, + { + "source": "detectorName", + "target": "DetectorName" + }, + { + "source": "evaluationFrequency", + "target": "EvaluationFrequency" + }, + { + "source": "filterPattern", + "target": "FilterPattern" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "logGroupArnList", + "target": "LogGroupArnList" + } + ], + "operation": "CreateLogAnomalyDetector", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::LogAnomalyDetector", + "mappings": [], + "operation": "DeleteLogAnomalyDetector", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::LogGroup", + "mappings": [ + { + "source": "deletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "logGroupClass", + "target": "LogGroupClass" + }, + { + "source": "logGroupName", + "target": "LogGroupName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateLogGroup", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::LogGroup", + "mappings": [ + { + "source": "logGroupName", + "target": "LogGroupName" + } + ], + "operation": "DeleteLogGroup", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::LogStream", + "mappings": [ + { + "source": "logGroupName", + "target": "LogGroupName" + }, + { + "source": "logStreamName", + "target": "LogStreamName" + } + ], + "operation": "CreateLogStream", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::LogStream", + "mappings": [ + { + "source": "logGroupName", + "target": "LogGroupName" + }, + { + "source": "logStreamName", + "target": "LogStreamName" + } + ], + "operation": "DeleteLogStream", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::MetricFilter", + "mappings": [ + { + "source": "applyOnTransformedLogs", + "target": "ApplyOnTransformedLogs" + }, + { + "source": "emitSystemFieldDimensions", + "target": "EmitSystemFieldDimensions" + }, + { + "source": "fieldSelectionCriteria", + "target": "FieldSelectionCriteria" + }, + { + "source": "filterName", + "target": "FilterName" + }, + { + "source": "filterPattern", + "target": "FilterPattern" + }, + { + "source": "logGroupName", + "target": "LogGroupName" + } + ], + "operation": "PutMetricFilter", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::MetricFilter", + "mappings": [ + { + "source": "filterName", + "target": "FilterName" + }, + { + "source": "logGroupName", + "target": "LogGroupName" + } + ], + "operation": "DeleteMetricFilter", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::QueryDefinition", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "logGroupNames", + "target": "LogGroupNames" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "queryLanguage", + "target": "QueryLanguage" + }, + { + "source": "queryString", + "target": "QueryString" + } + ], + "operation": "PutQueryDefinition", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::QueryDefinition", + "mappings": [], + "operation": "DeleteQueryDefinition", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::ResourcePolicy", + "mappings": [ + { + "source": "policyDocument", + "target": "PolicyDocument" + }, + { + "source": "policyName", + "target": "PolicyName" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::ResourcePolicy", + "mappings": [ + { + "source": "policyName", + "target": "PolicyName" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::ScheduledQuery", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "executionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "logGroupIdentifiers", + "target": "LogGroupIdentifiers" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "queryLanguage", + "target": "QueryLanguage" + }, + { + "source": "queryString", + "target": "QueryString" + }, + { + "source": "scheduleEndTime", + "target": "ScheduleEndTime" + }, + { + "source": "scheduleExpression", + "target": "ScheduleExpression" + }, + { + "source": "scheduleStartTime", + "target": "ScheduleStartTime" + }, + { + "source": "startTimeOffset", + "target": "StartTimeOffset" + }, + { + "source": "state", + "target": "State" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "timezone", + "target": "Timezone" + } + ], + "operation": "CreateScheduledQuery", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::ScheduledQuery", + "mappings": [], + "operation": "DeleteScheduledQuery", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::StorageTierPolicy", + "mappings": [ + { + "source": "storageTier", + "target": "StorageTier" + } + ], + "operation": "PutStorageTierPolicy", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::SubscriptionFilter", + "mappings": [ + { + "source": "applyOnTransformedLogs", + "target": "ApplyOnTransformedLogs" + }, + { + "source": "destinationArn", + "target": "DestinationArn" + }, + { + "source": "distribution", + "target": "Distribution" + }, + { + "source": "emitSystemFields", + "target": "EmitSystemFields" + }, + { + "source": "fieldSelectionCriteria", + "target": "FieldSelectionCriteria" + }, + { + "source": "filterName", + "target": "FilterName" + }, + { + "source": "filterPattern", + "target": "FilterPattern" + }, + { + "source": "logGroupName", + "target": "LogGroupName" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "PutSubscriptionFilter", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::SubscriptionFilter", + "mappings": [ + { + "source": "filterName", + "target": "FilterName" + }, + { + "source": "logGroupName", + "target": "LogGroupName" + } + ], + "operation": "DeleteSubscriptionFilter", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Transformer", + "mappings": [ + { + "source": "logGroupIdentifier", + "target": "LogGroupIdentifier" + } + ], + "operation": "PutTransformer", + "phase": "create", + "service": "logs" + }, + { + "cfn_type": "AWS::Logs::Transformer", + "mappings": [ + { + "source": "logGroupIdentifier", + "target": "LogGroupIdentifier" + } + ], + "operation": "DeleteTransformer", + "phase": "delete", + "service": "logs" + }, + { + "cfn_type": "AWS::LookoutEquipment::InferenceScheduler", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DataDelayOffsetInMinutes", + "target": "DataDelayOffsetInMinutes" + }, + { + "source": "DataUploadFrequency", + "target": "DataUploadFrequency" + }, + { + "source": "InferenceSchedulerName", + "target": "InferenceSchedulerName" + }, + { + "source": "ModelName", + "target": "ModelName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "ServerSideKmsKeyId", + "target": "ServerSideKmsKeyId" + } + ], + "operation": "CreateInferenceScheduler", + "phase": "create", + "service": "lookoutequipment" + }, + { + "cfn_type": "AWS::LookoutEquipment::InferenceScheduler", + "mappings": [ + { + "source": "InferenceSchedulerName", + "target": "InferenceSchedulerName" + } + ], + "operation": "DeleteInferenceScheduler", + "phase": "delete", + "service": "lookoutequipment" + }, + { + "cfn_type": "AWS::M2::Application", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "engineType", + "target": "EngineType" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "m2" + }, + { + "cfn_type": "AWS::M2::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "m2" + }, + { + "cfn_type": "AWS::M2::Deployment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "applicationVersion", + "target": "ApplicationVersion" + }, + { + "source": "environmentId", + "target": "EnvironmentId" + } + ], + "operation": "CreateDeployment", + "phase": "create", + "service": "m2" + }, + { + "cfn_type": "AWS::M2::Deployment", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "environmentId", + "target": "EnvironmentId" + } + ], + "operation": "DeleteApplicationFromEnvironment", + "phase": "delete", + "service": "m2" + }, + { + "cfn_type": "AWS::M2::Environment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "engineType", + "target": "EngineType" + }, + { + "source": "engineVersion", + "target": "EngineVersion" + }, + { + "source": "instanceType", + "target": "InstanceType" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "networkType", + "target": "NetworkType" + }, + { + "source": "preferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "publiclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "m2" + }, + { + "cfn_type": "AWS::M2::Environment", + "mappings": [], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "m2" + }, + { + "cfn_type": "AWS::MPA::ApprovalTeam", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateApprovalTeam", + "phase": "create", + "service": "mpa" + }, + { + "cfn_type": "AWS::MPA::IdentitySource", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateIdentitySource", + "phase": "create", + "service": "mpa" + }, + { + "cfn_type": "AWS::MPA::IdentitySource", + "mappings": [], + "operation": "DeleteIdentitySource", + "phase": "delete", + "service": "mpa" + }, + { + "cfn_type": "AWS::MSK::Channel", + "mappings": [ + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "ClusterArn", + "target": "ClusterArn" + } + ], + "operation": "CreateChannel", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Channel", + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + } + ], + "operation": "DeleteChannel", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Cluster", + "mappings": [ + { + "source": "ClusterName", + "target": "ClusterName" + }, + { + "source": "EnhancedMonitoring", + "target": "EnhancedMonitoring" + }, + { + "source": "KafkaVersion", + "target": "KafkaVersion" + }, + { + "source": "NumberOfBrokerNodes", + "target": "NumberOfBrokerNodes" + }, + { + "source": "StorageMode", + "target": "StorageMode" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Cluster", + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::ClusterPolicy", + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + }, + { + "source": "Policy", + "target": "Policy" + } + ], + "operation": "PutClusterPolicy", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::ClusterPolicy", + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + } + ], + "operation": "DeleteClusterPolicy", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Configuration", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConfiguration", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Configuration", + "mappings": [], + "operation": "DeleteConfiguration", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Replicator", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "ReplicatorName", + "target": "ReplicatorName" + }, + { + "source": "ServiceExecutionRoleArn", + "target": "ServiceExecutionRoleArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateReplicator", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Replicator", + "mappings": [], + "operation": "DeleteReplicator", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Topic", + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + }, + { + "source": "Configs", + "target": "Configs" + }, + { + "source": "PartitionCount", + "target": "PartitionCount" + }, + { + "source": "ReplicationFactor", + "target": "ReplicationFactor" + }, + { + "source": "TopicName", + "target": "TopicName" + } + ], + "operation": "CreateTopic", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::Topic", + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + }, + { + "source": "TopicName", + "target": "TopicName" + } + ], + "operation": "DeleteTopic", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::VpcConnection", + "mappings": [ + { + "source": "Authentication", + "target": "Authentication" + }, + { + "source": "ClientSubnets", + "target": "ClientSubnets" + }, + { + "source": "SecurityGroups", + "target": "SecurityGroups" + }, + { + "source": "TargetClusterArn", + "target": "TargetClusterArn" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcConnection", + "phase": "create", + "service": "kafka" + }, + { + "cfn_type": "AWS::MSK::VpcConnection", + "mappings": [], + "operation": "DeleteVpcConnection", + "phase": "delete", + "service": "kafka" + }, + { + "cfn_type": "AWS::MWAA::Environment", + "mappings": [ + { + "source": "AirflowVersion", + "target": "AirflowVersion" + }, + { + "source": "DagS3Path", + "target": "DagS3Path" + }, + { + "source": "EndpointManagement", + "target": "EndpointManagement" + }, + { + "source": "EnvironmentClass", + "target": "EnvironmentClass" + }, + { + "source": "ExecutionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "KmsKey", + "target": "KmsKey" + }, + { + "source": "MaxWebservers", + "target": "MaxWebservers" + }, + { + "source": "MaxWorkers", + "target": "MaxWorkers" + }, + { + "source": "MinWebservers", + "target": "MinWebservers" + }, + { + "source": "MinWorkers", + "target": "MinWorkers" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PluginsS3ObjectVersion", + "target": "PluginsS3ObjectVersion" + }, + { + "source": "PluginsS3Path", + "target": "PluginsS3Path" + }, + { + "source": "RequirementsS3ObjectVersion", + "target": "RequirementsS3ObjectVersion" + }, + { + "source": "RequirementsS3Path", + "target": "RequirementsS3Path" + }, + { + "source": "Schedulers", + "target": "Schedulers" + }, + { + "source": "SourceBucketArn", + "target": "SourceBucketArn" + }, + { + "source": "StartupScriptS3ObjectVersion", + "target": "StartupScriptS3ObjectVersion" + }, + { + "source": "StartupScriptS3Path", + "target": "StartupScriptS3Path" + }, + { + "source": "WebserverAccessMode", + "target": "WebserverAccessMode" + }, + { + "source": "WeeklyMaintenanceWindowStart", + "target": "WeeklyMaintenanceWindowStart" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "mwaa" + }, + { + "cfn_type": "AWS::MWAA::Environment", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "mwaa" + }, + { + "cfn_type": "AWS::MWAAServerless::Workflow", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "TriggerMode", + "target": "TriggerMode" + } + ], + "operation": "CreateWorkflow", + "phase": "create", + "service": "mwaa-serverless" + }, + { + "cfn_type": "AWS::MWAAServerless::Workflow", + "mappings": [], + "operation": "DeleteWorkflow", + "phase": "delete", + "service": "mwaa-serverless" + }, + { + "cfn_type": "AWS::Macie::AllowList", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAllowList", + "phase": "create", + "service": "macie2" + }, + { + "cfn_type": "AWS::Macie::AllowList", + "mappings": [], + "operation": "DeleteAllowList", + "phase": "delete", + "service": "macie2" + }, + { + "cfn_type": "AWS::Macie::CustomDataIdentifier", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "ignoreWords", + "target": "IgnoreWords" + }, + { + "source": "keywords", + "target": "Keywords" + }, + { + "source": "maximumMatchDistance", + "target": "MaximumMatchDistance" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "regex", + "target": "Regex" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCustomDataIdentifier", + "phase": "create", + "service": "macie2" + }, + { + "cfn_type": "AWS::Macie::CustomDataIdentifier", + "mappings": [], + "operation": "DeleteCustomDataIdentifier", + "phase": "delete", + "service": "macie2" + }, + { + "cfn_type": "AWS::Macie::FindingsFilter", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "action", + "target": "Action" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "position", + "target": "Position" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateFindingsFilter", + "phase": "create", + "service": "macie2" + }, + { + "cfn_type": "AWS::Macie::FindingsFilter", + "mappings": [], + "operation": "DeleteFindingsFilter", + "phase": "delete", + "service": "macie2" + }, + { + "cfn_type": "AWS::Macie::Session", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "findingPublishingFrequency", + "target": "FindingPublishingFrequency" + }, + { + "source": "status", + "target": "Status" + } + ], + "operation": "EnableMacie", + "phase": "create", + "service": "macie2" + }, + { + "cfn_type": "AWS::ManagedBlockchain::Accessor", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "AccessorType", + "target": "AccessorType" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateAccessor", + "phase": "create", + "service": "managedblockchain" + }, + { + "cfn_type": "AWS::ManagedBlockchain::Accessor", + "mappings": [], + "operation": "DeleteAccessor", + "phase": "delete", + "service": "managedblockchain" + }, + { + "cfn_type": "AWS::MediaConnect::Bridge", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "PlacementArn", + "target": "PlacementArn" + } + ], + "operation": "CreateBridge", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::Bridge", + "mappings": [], + "operation": "DeleteBridge", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::BridgeOutput", + "mappings": [ + { + "source": "BridgeArn", + "target": "BridgeArn" + } + ], + "operation": "AddBridgeOutputs", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::BridgeOutput", + "mappings": [ + { + "source": "BridgeArn", + "target": "BridgeArn" + } + ], + "operation": "RemoveBridgeOutput", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::BridgeSource", + "mappings": [ + { + "source": "BridgeArn", + "target": "BridgeArn" + } + ], + "operation": "AddBridgeSources", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::BridgeSource", + "mappings": [ + { + "source": "BridgeArn", + "target": "BridgeArn" + } + ], + "operation": "RemoveBridgeSource", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::Flow", + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "FlowSize", + "target": "FlowSize" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateFlow", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::Flow", + "mappings": [], + "operation": "DeleteFlow", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowEntitlement", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "GrantFlowEntitlements", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowEntitlement", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "RevokeFlowEntitlement", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowOutput", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "AddFlowOutputs", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowOutput", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "RemoveFlowOutput", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowSource", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "AddFlowSources", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowSource", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "RemoveFlowSource", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowVpcInterface", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "AddFlowVpcInterfaces", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::FlowVpcInterface", + "mappings": [ + { + "source": "FlowArn", + "target": "FlowArn" + } + ], + "operation": "RemoveFlowVpcInterface", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::Gateway", + "mappings": [ + { + "source": "EgressCidrBlocks", + "target": "EgressCidrBlocks" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateGateway", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::Gateway", + "mappings": [], + "operation": "DeleteGateway", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::RouterInput", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "MaximumBitrate", + "target": "MaximumBitrate" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RegionName", + "target": "RegionName" + }, + { + "source": "RoutingScope", + "target": "RoutingScope" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Tier", + "target": "Tier" + } + ], + "operation": "CreateRouterInput", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::RouterInput", + "mappings": [], + "operation": "DeleteRouterInput", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::RouterNetworkInterface", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "RegionName", + "target": "RegionName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRouterNetworkInterface", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::RouterNetworkInterface", + "mappings": [], + "operation": "DeleteRouterNetworkInterface", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::RouterOutput", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "MaximumBitrate", + "target": "MaximumBitrate" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RegionName", + "target": "RegionName" + }, + { + "source": "RoutingScope", + "target": "RoutingScope" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Tier", + "target": "Tier" + } + ], + "operation": "CreateRouterOutput", + "phase": "create", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConnect::RouterOutput", + "mappings": [], + "operation": "DeleteRouterOutput", + "phase": "delete", + "service": "mediaconnect" + }, + { + "cfn_type": "AWS::MediaConvert::Preset", + "mappings": [ + { + "source": "Category", + "target": "Category" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreatePreset", + "phase": "create", + "service": "mediaconvert" + }, + { + "cfn_type": "AWS::MediaConvert::Preset", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeletePreset", + "phase": "delete", + "service": "mediaconvert" + }, + { + "cfn_type": "AWS::MediaLive::ChannelPlacementGroup", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "ClusterId", + "target": "ClusterId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Nodes", + "target": "Nodes" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateChannelPlacementGroup", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::ChannelPlacementGroup", + "mappings": [ + { + "source": "ClusterId", + "target": "ClusterId" + } + ], + "operation": "DeleteChannelPlacementGroup", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::CloudWatchAlarmTemplate", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "ComparisonOperator", + "target": "ComparisonOperator" + }, + { + "source": "DatapointsToAlarm", + "target": "DatapointsToAlarm" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EvaluationPeriods", + "target": "EvaluationPeriods" + }, + { + "source": "GroupIdentifier", + "target": "GroupIdentifier" + }, + { + "source": "MetricName", + "target": "MetricName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Period", + "target": "Period" + }, + { + "source": "Statistic", + "target": "Statistic" + }, + { + "source": "TargetResourceType", + "target": "TargetResourceType" + }, + { + "source": "Threshold", + "target": "Threshold" + }, + { + "source": "TreatMissingData", + "target": "TreatMissingData" + } + ], + "operation": "CreateCloudWatchAlarmTemplate", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::CloudWatchAlarmTemplate", + "mappings": [], + "operation": "DeleteCloudWatchAlarmTemplate", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::CloudWatchAlarmTemplateGroup", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateCloudWatchAlarmTemplateGroup", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::CloudWatchAlarmTemplateGroup", + "mappings": [], + "operation": "DeleteCloudWatchAlarmTemplateGroup", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Cluster", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "ClusterType", + "target": "ClusterType" + }, + { + "source": "InstanceRoleArn", + "target": "InstanceRoleArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Cluster", + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::EventBridgeRuleTemplate", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventType", + "target": "EventType" + }, + { + "source": "GroupIdentifier", + "target": "GroupIdentifier" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateEventBridgeRuleTemplate", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::EventBridgeRuleTemplate", + "mappings": [], + "operation": "DeleteEventBridgeRuleTemplate", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::EventBridgeRuleTemplateGroup", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateEventBridgeRuleTemplateGroup", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::EventBridgeRuleTemplateGroup", + "mappings": [], + "operation": "DeleteEventBridgeRuleTemplateGroup", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Multiplex", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "AvailabilityZones", + "target": "AvailabilityZones" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateMultiplex", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Multiplex", + "mappings": [], + "operation": "DeleteMultiplex", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Multiplexprogram", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "MultiplexId", + "target": "MultiplexId" + }, + { + "source": "ProgramName", + "target": "ProgramName" + } + ], + "operation": "CreateMultiplexProgram", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Multiplexprogram", + "mappings": [ + { + "source": "MultiplexId", + "target": "MultiplexId" + }, + { + "source": "ProgramName", + "target": "ProgramName" + } + ], + "operation": "DeleteMultiplexProgram", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Network", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateNetwork", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Network", + "mappings": [], + "operation": "DeleteNetwork", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Node", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "ClusterId", + "target": "ClusterId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateNode", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::Node", + "mappings": [ + { + "source": "ClusterId", + "target": "ClusterId" + } + ], + "operation": "DeleteNode", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::SdiSource", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "Mode", + "target": "Mode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateSdiSource", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::SdiSource", + "mappings": [], + "operation": "DeleteSdiSource", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::SignalMap", + "ignored_inputs": [ + "RequestId" + ], + "mappings": [ + { + "source": "CloudWatchAlarmTemplateGroupIdentifiers", + "target": "CloudWatchAlarmTemplateGroupIdentifiers" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DiscoveryEntryPointArn", + "target": "DiscoveryEntryPointArn" + }, + { + "source": "EventBridgeRuleTemplateGroupIdentifiers", + "target": "EventBridgeRuleTemplateGroupIdentifiers" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateSignalMap", + "phase": "create", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaLive::SignalMap", + "mappings": [], + "operation": "DeleteSignalMap", + "phase": "delete", + "service": "medialive" + }, + { + "cfn_type": "AWS::MediaPackage::Asset", + "mappings": [ + { + "source": "Id", + "target": "Id" + }, + { + "source": "PackagingGroupId", + "target": "PackagingGroupId" + }, + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "SourceArn", + "target": "SourceArn" + }, + { + "source": "SourceRoleArn", + "target": "SourceRoleArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateAsset", + "phase": "create", + "service": "mediapackage-vod" + }, + { + "cfn_type": "AWS::MediaPackage::Asset", + "mappings": [ + { + "source": "Id", + "target": "Id" + } + ], + "operation": "DeleteAsset", + "phase": "delete", + "service": "mediapackage-vod" + }, + { + "cfn_type": "AWS::MediaPackage::Channel", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Id", + "target": "Id" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateChannel", + "phase": "create", + "service": "mediapackage" + }, + { + "cfn_type": "AWS::MediaPackage::Channel", + "mappings": [ + { + "source": "Id", + "target": "Id" + } + ], + "operation": "DeleteChannel", + "phase": "delete", + "service": "mediapackage" + }, + { + "cfn_type": "AWS::MediaPackage::OriginEndpoint", + "mappings": [ + { + "source": "ChannelId", + "target": "ChannelId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Id", + "target": "Id" + }, + { + "source": "ManifestName", + "target": "ManifestName" + }, + { + "source": "Origination", + "target": "Origination" + }, + { + "source": "StartoverWindowSeconds", + "target": "StartoverWindowSeconds" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TimeDelaySeconds", + "target": "TimeDelaySeconds" + }, + { + "source": "Whitelist", + "target": "Whitelist" + } + ], + "operation": "CreateOriginEndpoint", + "phase": "create", + "service": "mediapackage" + }, + { + "cfn_type": "AWS::MediaPackage::OriginEndpoint", + "mappings": [ + { + "source": "Id", + "target": "Id" + } + ], + "operation": "DeleteOriginEndpoint", + "phase": "delete", + "service": "mediapackage" + }, + { + "cfn_type": "AWS::MediaPackage::PackagingConfiguration", + "mappings": [ + { + "source": "Id", + "target": "Id" + }, + { + "source": "PackagingGroupId", + "target": "PackagingGroupId" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePackagingConfiguration", + "phase": "create", + "service": "mediapackage-vod" + }, + { + "cfn_type": "AWS::MediaPackage::PackagingConfiguration", + "mappings": [ + { + "source": "Id", + "target": "Id" + } + ], + "operation": "DeletePackagingConfiguration", + "phase": "delete", + "service": "mediapackage-vod" + }, + { + "cfn_type": "AWS::MediaPackage::PackagingGroup", + "mappings": [ + { + "source": "Id", + "target": "Id" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreatePackagingGroup", + "phase": "create", + "service": "mediapackage-vod" + }, + { + "cfn_type": "AWS::MediaPackage::PackagingGroup", + "mappings": [ + { + "source": "Id", + "target": "Id" + } + ], + "operation": "DeletePackagingGroup", + "phase": "delete", + "service": "mediapackage-vod" + }, + { + "cfn_type": "AWS::MediaPackageV2::Channel", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "InputType", + "target": "InputType" + }, + { + "source": "OutputLockingMode", + "target": "OutputLockingMode" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateChannel", + "phase": "create", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::Channel", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + } + ], + "operation": "DeleteChannel", + "phase": "delete", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::ChannelGroup", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateChannelGroup", + "phase": "create", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::ChannelGroup", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + } + ], + "operation": "DeleteChannelGroup", + "phase": "delete", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::ChannelPolicy", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "Policy", + "target": "Policy" + } + ], + "operation": "PutChannelPolicy", + "phase": "create", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::ChannelPolicy", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + } + ], + "operation": "DeleteChannelPolicy", + "phase": "delete", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::OriginEndpoint", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "ContainerType", + "target": "ContainerType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "OriginEndpointName", + "target": "OriginEndpointName" + }, + { + "source": "StartoverWindowSeconds", + "target": "StartoverWindowSeconds" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "UriSeparator", + "target": "UriSeparator" + } + ], + "operation": "CreateOriginEndpoint", + "phase": "create", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::OriginEndpoint", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "OriginEndpointName", + "target": "OriginEndpointName" + } + ], + "operation": "DeleteOriginEndpoint", + "phase": "delete", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::OriginEndpointPolicy", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "OriginEndpointName", + "target": "OriginEndpointName" + }, + { + "source": "Policy", + "target": "Policy" + } + ], + "operation": "PutOriginEndpointPolicy", + "phase": "create", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaPackageV2::OriginEndpointPolicy", + "mappings": [ + { + "source": "ChannelGroupName", + "target": "ChannelGroupName" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "OriginEndpointName", + "target": "OriginEndpointName" + } + ], + "operation": "DeleteOriginEndpointPolicy", + "phase": "delete", + "service": "mediapackagev2" + }, + { + "cfn_type": "AWS::MediaTailor::Channel", + "mappings": [ + { + "source": "Audiences", + "target": "Audiences" + }, + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "PlaybackMode", + "target": "PlaybackMode" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "Tier", + "target": "Tier" + } + ], + "operation": "CreateChannel", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::Channel", + "mappings": [ + { + "source": "ChannelName", + "target": "ChannelName" + } + ], + "operation": "DeleteChannel", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::ChannelPolicy", + "mappings": [ + { + "source": "ChannelName", + "target": "ChannelName" + }, + { + "source": "Policy", + "target": "Policy" + } + ], + "operation": "PutChannelPolicy", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::ChannelPolicy", + "mappings": [ + { + "source": "ChannelName", + "target": "ChannelName" + } + ], + "operation": "DeleteChannelPolicy", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::Function", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "FunctionId", + "target": "FunctionId" + }, + { + "source": "FunctionType", + "target": "FunctionType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "PutFunction", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::Function", + "mappings": [ + { + "source": "FunctionId", + "target": "FunctionId" + } + ], + "operation": "DeleteFunction", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::LiveSource", + "mappings": [ + { + "source": "LiveSourceName", + "target": "LiveSourceName" + }, + { + "source": "SourceLocationName", + "target": "SourceLocationName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateLiveSource", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::LiveSource", + "mappings": [ + { + "source": "LiveSourceName", + "target": "LiveSourceName" + }, + { + "source": "SourceLocationName", + "target": "SourceLocationName" + } + ], + "operation": "DeleteLiveSource", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::PlaybackConfiguration", + "mappings": [ + { + "source": "AdDecisionServerUrl", + "target": "AdDecisionServerUrl" + }, + { + "source": "InsertionMode", + "target": "InsertionMode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PersonalizationThresholdSeconds", + "target": "PersonalizationThresholdSeconds" + }, + { + "source": "SlateAdUrl", + "target": "SlateAdUrl" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TranscodeProfileName", + "target": "TranscodeProfileName" + }, + { + "source": "VideoContentSourceUrl", + "target": "VideoContentSourceUrl" + } + ], + "operation": "PutPlaybackConfiguration", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::PlaybackConfiguration", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeletePlaybackConfiguration", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::SourceLocation", + "mappings": [ + { + "source": "SourceLocationName", + "target": "SourceLocationName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSourceLocation", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::SourceLocation", + "mappings": [ + { + "source": "SourceLocationName", + "target": "SourceLocationName" + } + ], + "operation": "DeleteSourceLocation", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::VodSource", + "mappings": [ + { + "source": "SourceLocationName", + "target": "SourceLocationName" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "VodSourceName", + "target": "VodSourceName" + } + ], + "operation": "CreateVodSource", + "phase": "create", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MediaTailor::VodSource", + "mappings": [ + { + "source": "SourceLocationName", + "target": "SourceLocationName" + }, + { + "source": "VodSourceName", + "target": "VodSourceName" + } + ], + "operation": "DeleteVodSource", + "phase": "delete", + "service": "mediatailor" + }, + { + "cfn_type": "AWS::MemoryDB::ACL", + "mappings": [ + { + "source": "ACLName", + "target": "ACLName" + }, + { + "source": "UserNames", + "target": "UserNames" + } + ], + "operation": "CreateACL", + "phase": "create", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::ACL", + "mappings": [ + { + "source": "ACLName", + "target": "ACLName" + } + ], + "operation": "DeleteACL", + "phase": "delete", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::Cluster", + "mappings": [ + { + "source": "ACLName", + "target": "ACLName" + }, + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "ClusterName", + "target": "ClusterName" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "IpDiscovery", + "target": "IpDiscovery" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MaintenanceWindow", + "target": "MaintenanceWindow" + }, + { + "source": "MultiRegionClusterName", + "target": "MultiRegionClusterName" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "NodeType", + "target": "NodeType" + }, + { + "source": "NumReplicasPerShard", + "target": "NumReplicasPerShard" + }, + { + "source": "NumShards", + "target": "NumShards" + }, + { + "source": "ParameterGroupName", + "target": "ParameterGroupName" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "SnapshotArns", + "target": "SnapshotArns" + }, + { + "source": "SnapshotName", + "target": "SnapshotName" + }, + { + "source": "SnapshotRetentionLimit", + "target": "SnapshotRetentionLimit" + }, + { + "source": "SnapshotWindow", + "target": "SnapshotWindow" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "SubnetGroupName", + "target": "SubnetGroupName" + }, + { + "source": "TLSEnabled", + "target": "TLSEnabled" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::Cluster", + "mappings": [ + { + "source": "ClusterName", + "target": "ClusterName" + }, + { + "source": "FinalSnapshotName", + "target": "FinalSnapshotName" + }, + { + "source": "MultiRegionClusterName", + "target": "MultiRegionClusterName" + } + ], + "operation": "DeleteCluster", + "phase": "delete", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::MultiRegionCluster", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "MultiRegionClusterNameSuffix", + "target": "MultiRegionClusterNameSuffix" + }, + { + "source": "MultiRegionParameterGroupName", + "target": "MultiRegionParameterGroupName" + }, + { + "source": "NodeType", + "target": "NodeType" + }, + { + "source": "NumShards", + "target": "NumShards" + }, + { + "source": "TLSEnabled", + "target": "TLSEnabled" + } + ], + "operation": "CreateMultiRegionCluster", + "phase": "create", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::MultiRegionCluster", + "mappings": [], + "operation": "DeleteMultiRegionCluster", + "phase": "delete", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::ParameterGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Family", + "target": "Family" + }, + { + "source": "ParameterGroupName", + "target": "ParameterGroupName" + } + ], + "operation": "CreateParameterGroup", + "phase": "create", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::ParameterGroup", + "mappings": [ + { + "source": "ParameterGroupName", + "target": "ParameterGroupName" + } + ], + "operation": "DeleteParameterGroup", + "phase": "delete", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::SubnetGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "SubnetGroupName", + "target": "SubnetGroupName" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateSubnetGroup", + "phase": "create", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::SubnetGroup", + "mappings": [ + { + "source": "SubnetGroupName", + "target": "SubnetGroupName" + } + ], + "operation": "DeleteSubnetGroup", + "phase": "delete", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::User", + "mappings": [ + { + "source": "AccessString", + "target": "AccessString" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "CreateUser", + "phase": "create", + "service": "memorydb" + }, + { + "cfn_type": "AWS::MemoryDB::User", + "mappings": [ + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "DeleteUser", + "phase": "delete", + "service": "memorydb" + }, + { + "cfn_type": "AWS::Neptune::DBCluster", + "mappings": [ + { + "source": "AvailabilityZones", + "target": "AvailabilityZones" + }, + { + "source": "BackupRetentionPeriod", + "target": "BackupRetentionPeriod" + }, + { + "source": "CopyTagsToSnapshot", + "target": "CopyTagsToSnapshot" + }, + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + }, + { + "source": "DBClusterParameterGroupName", + "target": "DBClusterParameterGroupName" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "EnableCloudwatchLogsExports", + "target": "EnableCloudwatchLogsExports" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "PreferredBackupWindow", + "target": "PreferredBackupWindow" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "StorageEncrypted", + "target": "StorageEncrypted" + }, + { + "source": "VpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + } + ], + "operation": "CreateDBCluster", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBCluster", + "mappings": [ + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + } + ], + "operation": "DeleteDBCluster", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBClusterParameterGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateDBClusterParameterGroup", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBClusterParameterGroup", + "mappings": [], + "operation": "DeleteDBClusterParameterGroup", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBInstance", + "mappings": [ + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + }, + { + "source": "DBInstanceClass", + "target": "DBInstanceClass" + }, + { + "source": "DBInstanceIdentifier", + "target": "DBInstanceIdentifier" + }, + { + "source": "DBParameterGroupName", + "target": "DBParameterGroupName" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + } + ], + "operation": "CreateDBInstance", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBInstance", + "mappings": [ + { + "source": "DBInstanceIdentifier", + "target": "DBInstanceIdentifier" + } + ], + "operation": "DeleteDBInstance", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBParameterGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateDBParameterGroup", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBParameterGroup", + "mappings": [], + "operation": "DeleteDBParameterGroup", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBSubnetGroup", + "mappings": [ + { + "source": "DBSubnetGroupDescription", + "target": "DBSubnetGroupDescription" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateDBSubnetGroup", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::DBSubnetGroup", + "mappings": [ + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + } + ], + "operation": "DeleteDBSubnetGroup", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::EventSubscription", + "mappings": [ + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "EventCategories", + "target": "EventCategories" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "SourceIds", + "target": "SourceIds" + }, + { + "source": "SourceType", + "target": "SourceType" + }, + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "CreateEventSubscription", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::EventSubscription", + "mappings": [ + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "DeleteEventSubscription", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::GlobalCluster", + "mappings": [ + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + }, + { + "source": "SourceDBClusterIdentifier", + "target": "SourceDBClusterIdentifier" + }, + { + "source": "StorageEncrypted", + "target": "StorageEncrypted" + } + ], + "operation": "CreateGlobalCluster", + "phase": "create", + "service": "neptune" + }, + { + "cfn_type": "AWS::Neptune::GlobalCluster", + "mappings": [ + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + } + ], + "operation": "DeleteGlobalCluster", + "phase": "delete", + "service": "neptune" + }, + { + "cfn_type": "AWS::NeptuneGraph::Graph", + "mappings": [ + { + "source": "deletionProtection", + "target": "DeletionProtection" + }, + { + "source": "graphName", + "target": "GraphName" + }, + { + "source": "kmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "provisionedMemory", + "target": "ProvisionedMemory" + }, + { + "source": "publicConnectivity", + "target": "PublicConnectivity" + }, + { + "source": "replicaCount", + "target": "ReplicaCount" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateGraph", + "phase": "create", + "service": "neptune-graph" + }, + { + "cfn_type": "AWS::NeptuneGraph::Graph", + "mappings": [], + "operation": "DeleteGraph", + "phase": "delete", + "service": "neptune-graph" + }, + { + "cfn_type": "AWS::NeptuneGraph::GraphSnapshot", + "mappings": [ + { + "source": "graphIdentifier", + "target": "GraphIdentifier" + }, + { + "source": "snapshotName", + "target": "SnapshotName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateGraphSnapshot", + "phase": "create", + "service": "neptune-graph" + }, + { + "cfn_type": "AWS::NeptuneGraph::GraphSnapshot", + "mappings": [], + "operation": "DeleteGraphSnapshot", + "phase": "delete", + "service": "neptune-graph" + }, + { + "cfn_type": "AWS::NeptuneGraph::PrivateGraphEndpoint", + "mappings": [ + { + "source": "graphIdentifier", + "target": "GraphIdentifier" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreatePrivateGraphEndpoint", + "phase": "create", + "service": "neptune-graph" + }, + { + "cfn_type": "AWS::NeptuneGraph::PrivateGraphEndpoint", + "mappings": [ + { + "source": "graphIdentifier", + "target": "GraphIdentifier" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "DeletePrivateGraphEndpoint", + "phase": "delete", + "service": "neptune-graph" + }, + { + "cfn_type": "AWS::NetworkFirewall::Firewall", + "mappings": [ + { + "source": "AvailabilityZoneChangeProtection", + "target": "AvailabilityZoneChangeProtection" + }, + { + "source": "DeleteProtection", + "target": "DeleteProtection" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnabledAnalysisTypes", + "target": "EnabledAnalysisTypes" + }, + { + "source": "FirewallName", + "target": "FirewallName" + }, + { + "source": "FirewallPolicyArn", + "target": "FirewallPolicyArn" + }, + { + "source": "FirewallPolicyChangeProtection", + "target": "FirewallPolicyChangeProtection" + }, + { + "source": "SubnetChangeProtection", + "target": "SubnetChangeProtection" + }, + { + "source": "TransitGatewayId", + "target": "TransitGatewayId" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateFirewall", + "phase": "create", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::Firewall", + "mappings": [ + { + "source": "FirewallName", + "target": "FirewallName" + } + ], + "operation": "DeleteFirewall", + "phase": "delete", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::FirewallPolicy", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "FirewallPolicyName", + "target": "FirewallPolicyName" + } + ], + "operation": "CreateFirewallPolicy", + "phase": "create", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::FirewallPolicy", + "mappings": [ + { + "source": "FirewallPolicyName", + "target": "FirewallPolicyName" + } + ], + "operation": "DeleteFirewallPolicy", + "phase": "delete", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::RuleGroup", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "Capacity", + "target": "Capacity" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "RuleGroupName", + "target": "RuleGroupName" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateRuleGroup", + "phase": "create", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::RuleGroup", + "mappings": [ + { + "source": "RuleGroupName", + "target": "RuleGroupName" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "DeleteRuleGroup", + "phase": "delete", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::TLSInspectionConfiguration", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "TLSInspectionConfigurationName", + "target": "TLSInspectionConfigurationName" + } + ], + "operation": "CreateTLSInspectionConfiguration", + "phase": "create", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::TLSInspectionConfiguration", + "mappings": [ + { + "source": "TLSInspectionConfigurationName", + "target": "TLSInspectionConfigurationName" + } + ], + "operation": "DeleteTLSInspectionConfiguration", + "phase": "delete", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::VpcEndpointAssociation", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "FirewallArn", + "target": "FirewallArn" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcEndpointAssociation", + "phase": "create", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFirewall::VpcEndpointAssociation", + "mappings": [], + "operation": "DeleteVpcEndpointAssociation", + "phase": "delete", + "service": "network-firewall" + }, + { + "cfn_type": "AWS::NetworkFlowMonitor::Monitor", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "monitorName", + "target": "MonitorName" + }, + { + "source": "scopeArn", + "target": "ScopeArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateMonitor", + "phase": "create", + "service": "networkflowmonitor" + }, + { + "cfn_type": "AWS::NetworkFlowMonitor::Monitor", + "mappings": [ + { + "source": "monitorName", + "target": "MonitorName" + } + ], + "operation": "DeleteMonitor", + "phase": "delete", + "service": "networkflowmonitor" + }, + { + "cfn_type": "AWS::NetworkManager::ConnectAttachment", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "EdgeLocation", + "target": "EdgeLocation" + }, + { + "source": "RoutingPolicyLabel", + "target": "RoutingPolicyLabel" + }, + { + "source": "TransportAttachmentId", + "target": "TransportAttachmentId" + } + ], + "operation": "CreateConnectAttachment", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::ConnectPeer", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ConnectAttachmentId", + "target": "ConnectAttachmentId" + }, + { + "source": "CoreNetworkAddress", + "target": "CoreNetworkAddress" + }, + { + "source": "InsideCidrBlocks", + "target": "InsideCidrBlocks" + }, + { + "source": "PeerAddress", + "target": "PeerAddress" + }, + { + "source": "SubnetArn", + "target": "SubnetArn" + } + ], + "operation": "CreateConnectPeer", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::ConnectPeer", + "mappings": [], + "operation": "DeleteConnectPeer", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::CoreNetwork", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "PolicyDocument", + "target": "PolicyDocument" + } + ], + "operation": "CreateCoreNetwork", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::CoreNetwork", + "mappings": [], + "operation": "DeleteCoreNetwork", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::CoreNetworkPrefixListAssociation", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "PrefixListAlias", + "target": "PrefixListAlias" + }, + { + "source": "PrefixListArn", + "target": "PrefixListArn" + } + ], + "operation": "CreateCoreNetworkPrefixListAssociation", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::CoreNetworkPrefixListAssociation", + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "PrefixListArn", + "target": "PrefixListArn" + } + ], + "operation": "DeleteCoreNetworkPrefixListAssociation", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::CustomerGatewayAssociation", + "mappings": [ + { + "source": "CustomerGatewayArn", + "target": "CustomerGatewayArn" + }, + { + "source": "DeviceId", + "target": "DeviceId" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "LinkId", + "target": "LinkId" + } + ], + "operation": "AssociateCustomerGateway", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::CustomerGatewayAssociation", + "mappings": [ + { + "source": "CustomerGatewayArn", + "target": "CustomerGatewayArn" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + } + ], + "operation": "DisassociateCustomerGateway", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::Device", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "Model", + "target": "Model" + }, + { + "source": "SerialNumber", + "target": "SerialNumber" + }, + { + "source": "SiteId", + "target": "SiteId" + }, + { + "source": "Type", + "target": "Type" + }, + { + "source": "Vendor", + "target": "Vendor" + } + ], + "operation": "CreateDevice", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::Device", + "mappings": [ + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + } + ], + "operation": "DeleteDevice", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::DirectConnectGatewayAttachment", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "DirectConnectGatewayArn", + "target": "DirectConnectGatewayArn" + }, + { + "source": "EdgeLocations", + "target": "EdgeLocations" + }, + { + "source": "RoutingPolicyLabel", + "target": "RoutingPolicyLabel" + } + ], + "operation": "CreateDirectConnectGatewayAttachment", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::GlobalNetwork", + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateGlobalNetwork", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::GlobalNetwork", + "mappings": [], + "operation": "DeleteGlobalNetwork", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::Link", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "Provider", + "target": "Provider" + }, + { + "source": "SiteId", + "target": "SiteId" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateLink", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::Link", + "mappings": [ + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + } + ], + "operation": "DeleteLink", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::LinkAssociation", + "mappings": [ + { + "source": "DeviceId", + "target": "DeviceId" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "LinkId", + "target": "LinkId" + } + ], + "operation": "AssociateLink", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::LinkAssociation", + "mappings": [ + { + "source": "DeviceId", + "target": "DeviceId" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "LinkId", + "target": "LinkId" + } + ], + "operation": "DisassociateLink", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::Site", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + } + ], + "operation": "CreateSite", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::Site", + "mappings": [ + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + } + ], + "operation": "DeleteSite", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::SiteToSiteVpnAttachment", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "RoutingPolicyLabel", + "target": "RoutingPolicyLabel" + }, + { + "source": "VpnConnectionArn", + "target": "VpnConnectionArn" + } + ], + "operation": "CreateSiteToSiteVpnAttachment", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::TransitGatewayPeering", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "TransitGatewayArn", + "target": "TransitGatewayArn" + } + ], + "operation": "CreateTransitGatewayPeering", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::TransitGatewayRegistration", + "mappings": [ + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "TransitGatewayArn", + "target": "TransitGatewayArn" + } + ], + "operation": "RegisterTransitGateway", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::TransitGatewayRegistration", + "mappings": [ + { + "source": "GlobalNetworkId", + "target": "GlobalNetworkId" + }, + { + "source": "TransitGatewayArn", + "target": "TransitGatewayArn" + } + ], + "operation": "DeregisterTransitGateway", + "phase": "delete", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::TransitGatewayRouteTableAttachment", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "PeeringId", + "target": "PeeringId" + }, + { + "source": "RoutingPolicyLabel", + "target": "RoutingPolicyLabel" + }, + { + "source": "TransitGatewayRouteTableArn", + "target": "TransitGatewayRouteTableArn" + } + ], + "operation": "CreateTransitGatewayRouteTableAttachment", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::NetworkManager::VpcAttachment", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CoreNetworkId", + "target": "CoreNetworkId" + }, + { + "source": "RoutingPolicyLabel", + "target": "RoutingPolicyLabel" + }, + { + "source": "SubnetArns", + "target": "SubnetArns" + }, + { + "source": "VpcArn", + "target": "VpcArn" + } + ], + "operation": "CreateVpcAttachment", + "phase": "create", + "service": "networkmanager" + }, + { + "cfn_type": "AWS::Notifications::ChannelAssociation", + "mappings": [ + { + "source": "arn", + "target": "Arn" + }, + { + "source": "notificationConfigurationArn", + "target": "NotificationConfigurationArn" + } + ], + "operation": "AssociateChannel", + "phase": "create", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::ChannelAssociation", + "mappings": [ + { + "source": "arn", + "target": "Arn" + }, + { + "source": "notificationConfigurationArn", + "target": "NotificationConfigurationArn" + } + ], + "operation": "DisassociateChannel", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::EventRule", + "mappings": [ + { + "source": "eventPattern", + "target": "EventPattern" + }, + { + "source": "eventType", + "target": "EventType" + }, + { + "source": "notificationConfigurationArn", + "target": "NotificationConfigurationArn" + }, + { + "source": "regions", + "target": "Regions" + }, + { + "source": "source", + "target": "Source" + } + ], + "operation": "CreateEventRule", + "phase": "create", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::EventRule", + "mappings": [], + "operation": "DeleteEventRule", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::ManagedNotificationAccountContactAssociation", + "mappings": [ + { + "source": "contactIdentifier", + "target": "ContactIdentifier" + }, + { + "source": "managedNotificationConfigurationArn", + "target": "ManagedNotificationConfigurationArn" + } + ], + "operation": "AssociateManagedNotificationAccountContact", + "phase": "create", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::ManagedNotificationAccountContactAssociation", + "mappings": [ + { + "source": "contactIdentifier", + "target": "ContactIdentifier" + }, + { + "source": "managedNotificationConfigurationArn", + "target": "ManagedNotificationConfigurationArn" + } + ], + "operation": "DisassociateManagedNotificationAccountContact", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::ManagedNotificationAdditionalChannelAssociation", + "mappings": [ + { + "source": "channelArn", + "target": "ChannelArn" + }, + { + "source": "managedNotificationConfigurationArn", + "target": "ManagedNotificationConfigurationArn" + } + ], + "operation": "AssociateManagedNotificationAdditionalChannel", + "phase": "create", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::ManagedNotificationAdditionalChannelAssociation", + "mappings": [ + { + "source": "channelArn", + "target": "ChannelArn" + }, + { + "source": "managedNotificationConfigurationArn", + "target": "ManagedNotificationConfigurationArn" + } + ], + "operation": "DisassociateManagedNotificationAdditionalChannel", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::NotificationConfiguration", + "mappings": [ + { + "source": "aggregationDuration", + "target": "AggregationDuration" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateNotificationConfiguration", + "phase": "create", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::NotificationConfiguration", + "mappings": [], + "operation": "DeleteNotificationConfiguration", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::NotificationHub", + "mappings": [], + "operation": "DeregisterNotificationHub", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::OrganizationalUnitAssociation", + "mappings": [ + { + "source": "notificationConfigurationArn", + "target": "NotificationConfigurationArn" + }, + { + "source": "organizationalUnitId", + "target": "OrganizationalUnitId" + } + ], + "operation": "AssociateOrganizationalUnit", + "phase": "create", + "service": "notifications" + }, + { + "cfn_type": "AWS::Notifications::OrganizationalUnitAssociation", + "mappings": [ + { + "source": "notificationConfigurationArn", + "target": "NotificationConfigurationArn" + }, + { + "source": "organizationalUnitId", + "target": "OrganizationalUnitId" + } + ], + "operation": "DisassociateOrganizationalUnit", + "phase": "delete", + "service": "notifications" + }, + { + "cfn_type": "AWS::NotificationsContacts::EmailContact", + "mappings": [ + { + "source": "emailAddress", + "target": "EmailAddress" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateEmailContact", + "phase": "create", + "service": "notificationscontacts" + }, + { + "cfn_type": "AWS::NotificationsContacts::EmailContact", + "mappings": [], + "operation": "DeleteEmailContact", + "phase": "delete", + "service": "notificationscontacts" + }, + { + "cfn_type": "AWS::NovaAct::WorkflowDefinition", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateWorkflowDefinition", + "phase": "create", + "service": "nova-act" + }, + { + "cfn_type": "AWS::NovaAct::WorkflowDefinition", + "mappings": [], + "operation": "DeleteWorkflowDefinition", + "phase": "delete", + "service": "nova-act" + }, + { + "cfn_type": "AWS::ODB::CloudAutonomousVmCluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "autonomousDataStorageSizeInTBs", + "target": "AutonomousDataStorageSizeInTBs" + }, + { + "source": "cloudExadataInfrastructureId", + "target": "CloudExadataInfrastructureId" + }, + { + "source": "cpuCoreCountPerNode", + "target": "CpuCoreCountPerNode" + }, + { + "source": "dbServers", + "target": "DbServers" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "isMtlsEnabledVmCluster", + "target": "IsMtlsEnabledVmCluster" + }, + { + "source": "licenseModel", + "target": "LicenseModel" + }, + { + "source": "memoryPerOracleComputeUnitInGBs", + "target": "MemoryPerOracleComputeUnitInGBs" + }, + { + "source": "odbNetworkId", + "target": "OdbNetworkId" + }, + { + "source": "scanListenerPortNonTls", + "target": "ScanListenerPortNonTls" + }, + { + "source": "scanListenerPortTls", + "target": "ScanListenerPortTls" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "timeZone", + "target": "TimeZone" + }, + { + "source": "totalContainerDatabases", + "target": "TotalContainerDatabases" + } + ], + "operation": "CreateCloudAutonomousVmCluster", + "phase": "create", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::CloudAutonomousVmCluster", + "mappings": [], + "operation": "DeleteCloudAutonomousVmCluster", + "phase": "delete", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::CloudExadataInfrastructure", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "availabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "availabilityZoneId", + "target": "AvailabilityZoneId" + }, + { + "source": "computeCount", + "target": "ComputeCount" + }, + { + "source": "databaseServerType", + "target": "DatabaseServerType" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "shape", + "target": "Shape" + }, + { + "source": "storageCount", + "target": "StorageCount" + }, + { + "source": "storageServerType", + "target": "StorageServerType" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateCloudExadataInfrastructure", + "phase": "create", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::CloudExadataInfrastructure", + "mappings": [], + "operation": "DeleteCloudExadataInfrastructure", + "phase": "delete", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::CloudVmCluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "cloudExadataInfrastructureId", + "target": "CloudExadataInfrastructureId" + }, + { + "source": "clusterName", + "target": "ClusterName" + }, + { + "source": "cpuCoreCount", + "target": "CpuCoreCount" + }, + { + "source": "dataStorageSizeInTBs", + "target": "DataStorageSizeInTBs" + }, + { + "source": "dbNodeStorageSizeInGBs", + "target": "DbNodeStorageSizeInGBs" + }, + { + "source": "dbServers", + "target": "DbServers" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "giVersion", + "target": "GiVersion" + }, + { + "source": "hostname", + "target": "Hostname" + }, + { + "source": "isLocalBackupEnabled", + "target": "IsLocalBackupEnabled" + }, + { + "source": "isSparseDiskgroupEnabled", + "target": "IsSparseDiskgroupEnabled" + }, + { + "source": "licenseModel", + "target": "LicenseModel" + }, + { + "source": "memorySizeInGBs", + "target": "MemorySizeInGBs" + }, + { + "source": "odbNetworkId", + "target": "OdbNetworkId" + }, + { + "source": "scanListenerPortTcp", + "target": "ScanListenerPortTcp" + }, + { + "source": "sshPublicKeys", + "target": "SshPublicKeys" + }, + { + "source": "systemVersion", + "target": "SystemVersion" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "timeZone", + "target": "TimeZone" + } + ], + "operation": "CreateCloudVmCluster", + "phase": "create", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::CloudVmCluster", + "mappings": [], + "operation": "DeleteCloudVmCluster", + "phase": "delete", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::OdbNetwork", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "availabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "availabilityZoneId", + "target": "AvailabilityZoneId" + }, + { + "source": "backupSubnetCidr", + "target": "BackupSubnetCidr" + }, + { + "source": "clientSubnetCidr", + "target": "ClientSubnetCidr" + }, + { + "source": "customDomainName", + "target": "CustomDomainName" + }, + { + "source": "defaultDnsPrefix", + "target": "DefaultDnsPrefix" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "kmsAccess", + "target": "KmsAccess" + }, + { + "source": "kmsPolicyDocument", + "target": "KmsPolicyDocument" + }, + { + "source": "s3Access", + "target": "S3Access" + }, + { + "source": "s3PolicyDocument", + "target": "S3PolicyDocument" + }, + { + "source": "stsAccess", + "target": "StsAccess" + }, + { + "source": "stsPolicyDocument", + "target": "StsPolicyDocument" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "zeroEtlAccess", + "target": "ZeroEtlAccess" + } + ], + "operation": "CreateOdbNetwork", + "phase": "create", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::OdbNetwork", + "mappings": [ + { + "source": "deleteAssociatedResources", + "target": "DeleteAssociatedResources" + } + ], + "operation": "DeleteOdbNetwork", + "phase": "delete", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::OdbPeeringConnection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "odbNetworkId", + "target": "OdbNetworkId" + }, + { + "source": "peerNetworkId", + "target": "PeerNetworkId" + }, + { + "source": "peerNetworkRouteTableIds", + "target": "PeerNetworkRouteTableIds" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateOdbPeeringConnection", + "phase": "create", + "service": "odb" + }, + { + "cfn_type": "AWS::ODB::OdbPeeringConnection", + "mappings": [], + "operation": "DeleteOdbPeeringConnection", + "phase": "delete", + "service": "odb" + }, + { + "cfn_type": "AWS::OSIS::Pipeline", + "mappings": [ + { + "source": "MaxUnits", + "target": "MaxUnits" + }, + { + "source": "MinUnits", + "target": "MinUnits" + }, + { + "source": "PipelineConfigurationBody", + "target": "PipelineConfigurationBody" + }, + { + "source": "PipelineName", + "target": "PipelineName" + }, + { + "source": "PipelineRoleArn", + "target": "PipelineRoleArn" + } + ], + "operation": "CreatePipeline", + "phase": "create", + "service": "osis" + }, + { + "cfn_type": "AWS::OSIS::Pipeline", + "mappings": [ + { + "source": "PipelineName", + "target": "PipelineName" + } + ], + "operation": "DeletePipeline", + "phase": "delete", + "service": "osis" + }, + { + "cfn_type": "AWS::Oam::Link", + "mappings": [ + { + "source": "LabelTemplate", + "target": "LabelTemplate" + }, + { + "source": "ResourceTypes", + "target": "ResourceTypes" + }, + { + "source": "SinkIdentifier", + "target": "SinkIdentifier" + } + ], + "operation": "CreateLink", + "phase": "create", + "service": "oam" + }, + { + "cfn_type": "AWS::Oam::Link", + "mappings": [], + "operation": "DeleteLink", + "phase": "delete", + "service": "oam" + }, + { + "cfn_type": "AWS::Oam::Sink", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateSink", + "phase": "create", + "service": "oam" + }, + { + "cfn_type": "AWS::Oam::Sink", + "mappings": [], + "operation": "DeleteSink", + "phase": "delete", + "service": "oam" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::OrganizationCentralizationRule", + "mappings": [ + { + "source": "RuleName", + "target": "RuleName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCentralizationRuleForOrganization", + "phase": "create", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::OrganizationTelemetryRule", + "mappings": [ + { + "source": "RuleName", + "target": "RuleName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateTelemetryRuleForOrganization", + "phase": "create", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::S3TableIntegration", + "mappings": [ + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateS3TableIntegration", + "phase": "create", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::S3TableIntegration", + "mappings": [], + "operation": "DeleteS3TableIntegration", + "phase": "delete", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::TelemetryPipelines", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateTelemetryPipeline", + "phase": "create", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::TelemetryRule", + "mappings": [ + { + "source": "RuleName", + "target": "RuleName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateTelemetryRule", + "phase": "create", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::ObservabilityAdmin::TelemetryRule", + "mappings": [], + "operation": "DeleteTelemetryRule", + "phase": "delete", + "service": "observabilityadmin" + }, + { + "cfn_type": "AWS::Omics::AnnotationStore", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "storeFormat", + "target": "StoreFormat" + } + ], + "operation": "CreateAnnotationStore", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::AnnotationStore", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteAnnotationStore", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::Configuration", + "ignored_inputs": [ + "requestId" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateConfiguration", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::Configuration", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteConfiguration", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::ReferenceStore", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateReferenceStore", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::ReferenceStore", + "mappings": [], + "operation": "DeleteReferenceStore", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::RunGroup", + "ignored_inputs": [ + "requestId" + ], + "mappings": [ + { + "source": "maxCpus", + "target": "MaxCpus" + }, + { + "source": "maxDuration", + "target": "MaxDuration" + }, + { + "source": "maxGpus", + "target": "MaxGpus" + }, + { + "source": "maxRuns", + "target": "MaxRuns" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateRunGroup", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::RunGroup", + "mappings": [], + "operation": "DeleteRunGroup", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::SequenceStore", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "eTagAlgorithmFamily", + "target": "ETagAlgorithmFamily" + }, + { + "source": "fallbackLocation", + "target": "FallbackLocation" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "propagatedSetLevelTags", + "target": "PropagatedSetLevelTags" + } + ], + "operation": "CreateSequenceStore", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::SequenceStore", + "mappings": [], + "operation": "DeleteSequenceStore", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::VariantStore", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateVariantStore", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::VariantStore", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteVariantStore", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::Workflow", + "ignored_inputs": [ + "requestId" + ], + "mappings": [ + { + "source": "accelerators", + "target": "Accelerators" + }, + { + "source": "containerRegistryMapUri", + "target": "ContainerRegistryMapUri" + }, + { + "source": "definitionUri", + "target": "DefinitionUri" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "engine", + "target": "Engine" + }, + { + "source": "main", + "target": "Main" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "parameterTemplatePath", + "target": "ParameterTemplatePath" + }, + { + "source": "readmeMarkdown", + "target": "readmeMarkdown" + }, + { + "source": "readmePath", + "target": "readmePath" + }, + { + "source": "readmeUri", + "target": "readmeUri" + }, + { + "source": "storageCapacity", + "target": "StorageCapacity" + }, + { + "source": "storageType", + "target": "StorageType" + }, + { + "source": "workflowBucketOwnerId", + "target": "WorkflowBucketOwnerId" + } + ], + "operation": "CreateWorkflow", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::Workflow", + "mappings": [], + "operation": "DeleteWorkflow", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::WorkflowVersion", + "ignored_inputs": [ + "requestId" + ], + "mappings": [ + { + "source": "accelerators", + "target": "Accelerators" + }, + { + "source": "containerRegistryMapUri", + "target": "ContainerRegistryMapUri" + }, + { + "source": "definitionUri", + "target": "DefinitionUri" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "engine", + "target": "Engine" + }, + { + "source": "main", + "target": "Main" + }, + { + "source": "parameterTemplatePath", + "target": "ParameterTemplatePath" + }, + { + "source": "readmeMarkdown", + "target": "readmeMarkdown" + }, + { + "source": "readmePath", + "target": "readmePath" + }, + { + "source": "readmeUri", + "target": "readmeUri" + }, + { + "source": "storageCapacity", + "target": "StorageCapacity" + }, + { + "source": "storageType", + "target": "StorageType" + }, + { + "source": "versionName", + "target": "VersionName" + }, + { + "source": "workflowBucketOwnerId", + "target": "WorkflowBucketOwnerId" + }, + { + "source": "workflowId", + "target": "WorkflowId" + } + ], + "operation": "CreateWorkflowVersion", + "phase": "create", + "service": "omics" + }, + { + "cfn_type": "AWS::Omics::WorkflowVersion", + "mappings": [ + { + "source": "versionName", + "target": "VersionName" + }, + { + "source": "workflowId", + "target": "WorkflowId" + } + ], + "operation": "DeleteWorkflowVersion", + "phase": "delete", + "service": "omics" + }, + { + "cfn_type": "AWS::OpenSearch::DataSource", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "AddDataSource", + "phase": "create", + "service": "opensearch" + }, + { + "cfn_type": "AWS::OpenSearch::DataSource", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "opensearch" + }, + { + "cfn_type": "AWS::OpenSearchServerless::AccessPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policy", + "target": "Policy" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateAccessPolicy", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::AccessPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "DeleteAccessPolicy", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::Collection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "collectionGroupName", + "target": "CollectionGroupName" + }, + { + "source": "deletionProtection", + "target": "DeletionProtection" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "standbyReplicas", + "target": "StandbyReplicas" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateCollection", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::Collection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteCollection", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::CollectionGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "generation", + "target": "Generation" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "standbyReplicas", + "target": "StandbyReplicas" + } + ], + "operation": "CreateCollectionGroup", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::CollectionGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteCollectionGroup", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::CollectionIndex", + "mappings": [ + { + "source": "id", + "target": "Id" + }, + { + "source": "indexName", + "target": "IndexName" + } + ], + "operation": "CreateIndex", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::CollectionIndex", + "mappings": [ + { + "source": "id", + "target": "Id" + }, + { + "source": "indexName", + "target": "IndexName" + } + ], + "operation": "DeleteIndex", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::LifecyclePolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policy", + "target": "Policy" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateLifecyclePolicy", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::LifecyclePolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "DeleteLifecyclePolicy", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::SecurityConfig", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateSecurityConfig", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::SecurityConfig", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteSecurityConfig", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::SecurityPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policy", + "target": "Policy" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateSecurityPolicy", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::SecurityPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "DeleteSecurityPolicy", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::VpcEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreateVpcEndpoint", + "phase": "create", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchServerless::VpcEndpoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteVpcEndpoint", + "phase": "delete", + "service": "opensearchserverless" + }, + { + "cfn_type": "AWS::OpenSearchService::Domain", + "mappings": [ + { + "source": "DomainName", + "target": "DomainName" + } + ], + "operation": "DeleteDomain", + "phase": "delete", + "service": "opensearch" + }, + { + "cfn_type": "AWS::Organizations::Account", + "mappings": [ + { + "source": "AccountName", + "target": "AccountName" + }, + { + "source": "Email", + "target": "Email" + }, + { + "source": "RoleName", + "target": "RoleName" + } + ], + "operation": "CreateAccount", + "phase": "create", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::Organization", + "mappings": [ + { + "source": "FeatureSet", + "target": "FeatureSet" + } + ], + "operation": "CreateOrganization", + "phase": "create", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::Organization", + "mappings": [], + "operation": "DeleteOrganization", + "phase": "delete", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::OrganizationalUnit", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "ParentId", + "target": "ParentId" + } + ], + "operation": "CreateOrganizationalUnit", + "phase": "create", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::OrganizationalUnit", + "mappings": [], + "operation": "DeleteOrganizationalUnit", + "phase": "delete", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::Policy", + "mappings": [ + { + "source": "Content", + "target": "Content" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreatePolicy", + "phase": "create", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::Policy", + "mappings": [], + "operation": "DeletePolicy", + "phase": "delete", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::ResourcePolicy", + "mappings": [ + { + "source": "Content", + "target": "Content" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "organizations" + }, + { + "cfn_type": "AWS::Organizations::ResourcePolicy", + "mappings": [], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "organizations" + }, + { + "cfn_type": "AWS::Outposts::Site", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Notes", + "target": "Notes" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSite", + "phase": "create", + "service": "outposts" + }, + { + "cfn_type": "AWS::Outposts::Site", + "mappings": [], + "operation": "DeleteSite", + "phase": "delete", + "service": "outposts" + }, + { + "cfn_type": "AWS::PCAConnectorAD::Connector", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CertificateAuthorityArn", + "target": "CertificateAuthorityArn" + }, + { + "source": "DirectoryId", + "target": "DirectoryId" + } + ], + "operation": "CreateConnector", + "phase": "create", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::Connector", + "mappings": [], + "operation": "DeleteConnector", + "phase": "delete", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::DirectoryRegistration", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DirectoryId", + "target": "DirectoryId" + } + ], + "operation": "CreateDirectoryRegistration", + "phase": "create", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::DirectoryRegistration", + "mappings": [], + "operation": "DeleteDirectoryRegistration", + "phase": "delete", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::ServicePrincipalName", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ConnectorArn", + "target": "ConnectorArn" + }, + { + "source": "DirectoryRegistrationArn", + "target": "DirectoryRegistrationArn" + } + ], + "operation": "CreateServicePrincipalName", + "phase": "create", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::ServicePrincipalName", + "mappings": [ + { + "source": "ConnectorArn", + "target": "ConnectorArn" + }, + { + "source": "DirectoryRegistrationArn", + "target": "DirectoryRegistrationArn" + } + ], + "operation": "DeleteServicePrincipalName", + "phase": "delete", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::Template", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ConnectorArn", + "target": "ConnectorArn" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateTemplate", + "phase": "create", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::Template", + "mappings": [], + "operation": "DeleteTemplate", + "phase": "delete", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::TemplateGroupAccessControlEntry", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "GroupDisplayName", + "target": "GroupDisplayName" + }, + { + "source": "GroupSecurityIdentifier", + "target": "GroupSecurityIdentifier" + }, + { + "source": "TemplateArn", + "target": "TemplateArn" + } + ], + "operation": "CreateTemplateGroupAccessControlEntry", + "phase": "create", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorAD::TemplateGroupAccessControlEntry", + "mappings": [ + { + "source": "GroupSecurityIdentifier", + "target": "GroupSecurityIdentifier" + }, + { + "source": "TemplateArn", + "target": "TemplateArn" + } + ], + "operation": "DeleteTemplateGroupAccessControlEntry", + "phase": "delete", + "service": "pca-connector-ad" + }, + { + "cfn_type": "AWS::PCAConnectorSCEP::Challenge", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ConnectorArn", + "target": "ConnectorArn" + } + ], + "operation": "CreateChallenge", + "phase": "create", + "service": "pca-connector-scep" + }, + { + "cfn_type": "AWS::PCAConnectorSCEP::Challenge", + "mappings": [], + "operation": "DeleteChallenge", + "phase": "delete", + "service": "pca-connector-scep" + }, + { + "cfn_type": "AWS::PCAConnectorSCEP::Connector", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CertificateAuthorityArn", + "target": "CertificateAuthorityArn" + }, + { + "source": "VpcEndpointId", + "target": "VpcEndpointId" + } + ], + "operation": "CreateConnector", + "phase": "create", + "service": "pca-connector-scep" + }, + { + "cfn_type": "AWS::PCAConnectorSCEP::Connector", + "mappings": [], + "operation": "DeleteConnector", + "phase": "delete", + "service": "pca-connector-scep" + }, + { + "cfn_type": "AWS::PCS::Cluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "size", + "target": "Size" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "pcs" + }, + { + "cfn_type": "AWS::PCS::Cluster", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "pcs" + }, + { + "cfn_type": "AWS::PCS::ComputeNodeGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "amiId", + "target": "AmiId" + }, + { + "source": "iamInstanceProfileArn", + "target": "IamInstanceProfileArn" + }, + { + "source": "purchaseOption", + "target": "PurchaseOption" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateComputeNodeGroup", + "phase": "create", + "service": "pcs" + }, + { + "cfn_type": "AWS::PCS::ComputeNodeGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteComputeNodeGroup", + "phase": "delete", + "service": "pcs" + }, + { + "cfn_type": "AWS::PCS::Queue", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteQueue", + "phase": "delete", + "service": "pcs" + }, + { + "cfn_type": "AWS::PaymentCryptography::Alias", + "mappings": [ + { + "source": "AliasName", + "target": "AliasName" + }, + { + "source": "KeyArn", + "target": "KeyArn" + } + ], + "operation": "CreateAlias", + "phase": "create", + "service": "payment-cryptography" + }, + { + "cfn_type": "AWS::PaymentCryptography::Alias", + "mappings": [ + { + "source": "AliasName", + "target": "AliasName" + } + ], + "operation": "DeleteAlias", + "phase": "delete", + "service": "payment-cryptography" + }, + { + "cfn_type": "AWS::PaymentCryptography::Key", + "mappings": [ + { + "source": "DeriveKeyUsage", + "target": "DeriveKeyUsage" + }, + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "Exportable", + "target": "Exportable" + }, + { + "source": "KeyCheckValueAlgorithm", + "target": "KeyCheckValueAlgorithm" + }, + { + "source": "ReplicationRegions", + "target": "ReplicationRegions" + } + ], + "operation": "CreateKey", + "phase": "create", + "service": "payment-cryptography" + }, + { + "cfn_type": "AWS::PaymentCryptography::Key", + "mappings": [], + "operation": "DeleteKey", + "phase": "delete", + "service": "payment-cryptography" + }, + { + "cfn_type": "AWS::Personalize::Dataset", + "mappings": [ + { + "source": "datasetGroupArn", + "target": "DatasetGroupArn" + }, + { + "source": "datasetType", + "target": "DatasetType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "schemaArn", + "target": "SchemaArn" + } + ], + "operation": "CreateDataset", + "phase": "create", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::Dataset", + "mappings": [], + "operation": "DeleteDataset", + "phase": "delete", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::DatasetGroup", + "mappings": [ + { + "source": "domain", + "target": "Domain" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateDatasetGroup", + "phase": "create", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::DatasetGroup", + "mappings": [], + "operation": "DeleteDatasetGroup", + "phase": "delete", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::EventTracker", + "mappings": [ + { + "source": "datasetGroupArn", + "target": "DatasetGroupArn" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateEventTracker", + "phase": "create", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::EventTracker", + "mappings": [], + "operation": "DeleteEventTracker", + "phase": "delete", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::Schema", + "mappings": [ + { + "source": "domain", + "target": "Domain" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "schema", + "target": "Schema" + } + ], + "operation": "CreateSchema", + "phase": "create", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::Schema", + "mappings": [], + "operation": "DeleteSchema", + "phase": "delete", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::Solution", + "mappings": [ + { + "source": "datasetGroupArn", + "target": "DatasetGroupArn" + }, + { + "source": "eventType", + "target": "EventType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "performAutoML", + "target": "PerformAutoML" + }, + { + "source": "performHPO", + "target": "PerformHPO" + }, + { + "source": "recipeArn", + "target": "RecipeArn" + } + ], + "operation": "CreateSolution", + "phase": "create", + "service": "personalize" + }, + { + "cfn_type": "AWS::Personalize::Solution", + "mappings": [], + "operation": "DeleteSolution", + "phase": "delete", + "service": "personalize" + }, + { + "cfn_type": "AWS::Pinpoint::InAppTemplate", + "mappings": [ + { + "source": "TemplateName", + "target": "TemplateName" + } + ], + "operation": "CreateInAppTemplate", + "phase": "create", + "service": "pinpoint" + }, + { + "cfn_type": "AWS::Pinpoint::InAppTemplate", + "mappings": [ + { + "source": "TemplateName", + "target": "TemplateName" + } + ], + "operation": "DeleteInAppTemplate", + "phase": "delete", + "service": "pinpoint" + }, + { + "cfn_type": "AWS::Pipes::Pipe", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DesiredState", + "target": "DesiredState" + }, + { + "source": "Enrichment", + "target": "Enrichment" + }, + { + "source": "KmsKeyIdentifier", + "target": "KmsKeyIdentifier" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Source", + "target": "Source" + }, + { + "source": "Target", + "target": "Target" + } + ], + "operation": "CreatePipe", + "phase": "create", + "service": "pipes" + }, + { + "cfn_type": "AWS::Pipes::Pipe", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeletePipe", + "phase": "delete", + "service": "pipes" + }, + { + "cfn_type": "AWS::Proton::EnvironmentAccountConnection", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "codebuildRoleArn", + "target": "CodebuildRoleArn" + }, + { + "source": "componentRoleArn", + "target": "ComponentRoleArn" + }, + { + "source": "environmentName", + "target": "EnvironmentName" + }, + { + "source": "managementAccountId", + "target": "ManagementAccountId" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateEnvironmentAccountConnection", + "phase": "create", + "service": "proton" + }, + { + "cfn_type": "AWS::Proton::EnvironmentAccountConnection", + "mappings": [], + "operation": "DeleteEnvironmentAccountConnection", + "phase": "delete", + "service": "proton" + }, + { + "cfn_type": "AWS::Proton::EnvironmentTemplate", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "encryptionKey", + "target": "EncryptionKey" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "provisioning", + "target": "Provisioning" + } + ], + "operation": "CreateEnvironmentTemplate", + "phase": "create", + "service": "proton" + }, + { + "cfn_type": "AWS::Proton::EnvironmentTemplate", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteEnvironmentTemplate", + "phase": "delete", + "service": "proton" + }, + { + "cfn_type": "AWS::Proton::ServiceTemplate", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "encryptionKey", + "target": "EncryptionKey" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "pipelineProvisioning", + "target": "PipelineProvisioning" + } + ], + "operation": "CreateServiceTemplate", + "phase": "create", + "service": "proton" + }, + { + "cfn_type": "AWS::Proton::ServiceTemplate", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteServiceTemplate", + "phase": "delete", + "service": "proton" + }, + { + "cfn_type": "AWS::QBusiness::Application", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "clientIdsForOIDC", + "target": "ClientIdsForOIDC" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "iamIdentityProviderArn", + "target": "IamIdentityProviderArn" + }, + { + "source": "identityCenterInstanceArn", + "target": "IdentityCenterInstanceArn" + }, + { + "source": "identityType", + "target": "IdentityType" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::DataAccessor", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "principal", + "target": "Principal" + } + ], + "operation": "CreateDataAccessor", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::DataAccessor", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + } + ], + "operation": "DeleteDataAccessor", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::DataSource", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "indexId", + "target": "IndexId" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "syncSchedule", + "target": "SyncSchedule" + } + ], + "operation": "CreateDataSource", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::DataSource", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "indexId", + "target": "IndexId" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Index", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateIndex", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Index", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + } + ], + "operation": "DeleteIndex", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Permission", + "mappings": [ + { + "source": "actions", + "target": "Actions" + }, + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "principal", + "target": "Principal" + }, + { + "source": "statementId", + "target": "StatementId" + } + ], + "operation": "AssociatePermission", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Permission", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "statementId", + "target": "StatementId" + } + ], + "operation": "DisassociatePermission", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Plugin", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "serverUrl", + "target": "ServerUrl" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreatePlugin", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Plugin", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + } + ], + "operation": "DeletePlugin", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Retriever", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateRetriever", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::Retriever", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + } + ], + "operation": "DeleteRetriever", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::WebExperience", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + }, + { + "source": "origins", + "target": "Origins" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "samplePromptsControlMode", + "target": "SamplePromptsControlMode" + }, + { + "source": "subtitle", + "target": "Subtitle" + }, + { + "source": "title", + "target": "Title" + }, + { + "source": "welcomeMessage", + "target": "WelcomeMessage" + } + ], + "operation": "CreateWebExperience", + "phase": "create", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QBusiness::WebExperience", + "mappings": [ + { + "source": "applicationId", + "target": "ApplicationId" + } + ], + "operation": "DeleteWebExperience", + "phase": "delete", + "service": "qbusiness" + }, + { + "cfn_type": "AWS::QuickSight::ActionConnector", + "mappings": [ + { + "source": "ActionConnectorId", + "target": "ActionConnectorId" + }, + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Type", + "target": "Type" + }, + { + "source": "VpcConnectionArn", + "target": "VpcConnectionArn" + } + ], + "operation": "CreateActionConnector", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::ActionConnector", + "mappings": [ + { + "source": "ActionConnectorId", + "target": "ActionConnectorId" + }, + { + "source": "AwsAccountId", + "target": "AwsAccountId" + } + ], + "operation": "DeleteActionConnector", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Agent", + "mappings": [ + { + "source": "ActionConnectors", + "target": "ActionConnectors" + }, + { + "source": "AgentId", + "target": "AgentId" + }, + { + "source": "AgentLifecycle", + "target": "AgentLifecycle" + }, + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IconId", + "target": "IconId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Spaces", + "target": "Spaces" + }, + { + "source": "StarterPrompts", + "target": "StarterPrompts" + }, + { + "source": "WelcomeMessage", + "target": "WelcomeMessage" + } + ], + "operation": "CreateAgent", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Agent", + "mappings": [ + { + "source": "AgentId", + "target": "AgentId" + }, + { + "source": "AwsAccountId", + "target": "AwsAccountId" + } + ], + "operation": "DeleteAgent", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Analysis", + "mappings": [ + { + "source": "AnalysisId", + "target": "AnalysisId" + }, + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "FolderArns", + "target": "FolderArns" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ThemeArn", + "target": "ThemeArn" + } + ], + "operation": "CreateAnalysis", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Analysis", + "mappings": [ + { + "source": "AnalysisId", + "target": "AnalysisId" + }, + { + "source": "AwsAccountId", + "target": "AwsAccountId" + } + ], + "operation": "DeleteAnalysis", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::CustomPermissions", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "CustomPermissionsName", + "target": "CustomPermissionsName" + } + ], + "operation": "CreateCustomPermissions", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::CustomPermissions", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "CustomPermissionsName", + "target": "CustomPermissionsName" + } + ], + "operation": "DeleteCustomPermissions", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Dashboard", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DashboardId", + "target": "DashboardId" + }, + { + "source": "FolderArns", + "target": "FolderArns" + }, + { + "source": "LinkEntities", + "target": "LinkEntities" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ThemeArn", + "target": "ThemeArn" + }, + { + "source": "VersionDescription", + "target": "VersionDescription" + } + ], + "operation": "CreateDashboard", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Dashboard", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DashboardId", + "target": "DashboardId" + } + ], + "operation": "DeleteDashboard", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::DataSet", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSetId", + "target": "DataSetId" + }, + { + "source": "FolderArns", + "target": "FolderArns" + }, + { + "source": "ImportMode", + "target": "ImportMode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "UseAs", + "target": "UseAs" + } + ], + "operation": "CreateDataSet", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::DataSet", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSetId", + "target": "DataSetId" + } + ], + "operation": "DeleteDataSet", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::DataSource", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSourceId", + "target": "DataSourceId" + }, + { + "source": "FolderArns", + "target": "FolderArns" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateDataSource", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::DataSource", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSourceId", + "target": "DataSourceId" + } + ], + "operation": "DeleteDataSource", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Flow", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateFlow", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Flow", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + } + ], + "operation": "DeleteFlow", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Folder", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "FolderId", + "target": "FolderId" + }, + { + "source": "FolderType", + "target": "FolderType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ParentFolderArn", + "target": "ParentFolderArn" + }, + { + "source": "SharingModel", + "target": "SharingModel" + } + ], + "operation": "CreateFolder", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Folder", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "FolderId", + "target": "FolderId" + } + ], + "operation": "DeleteFolder", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::KnowledgeBase", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSourceArn", + "target": "DataSourceArn" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "KnowledgeBaseId", + "target": "KnowledgeBaseId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "PrimaryOwnerArn", + "target": "PrimaryOwnerArn" + } + ], + "operation": "CreateKnowledgeBase", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::KnowledgeBase", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "KnowledgeBaseId", + "target": "KnowledgeBaseId" + } + ], + "operation": "DeleteKnowledgeBase", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::OAuthClientApplication", + "mappings": [ + { + "source": "ClientId", + "target": "ClientId" + }, + { + "source": "ClientSecret", + "target": "ClientSecret" + }, + { + "source": "DataSourceType", + "target": "DataSourceType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OAuthAuthorizationEndpointUrl", + "target": "OAuthAuthorizationEndpointUrl" + }, + { + "source": "OAuthClientApplicationId", + "target": "OAuthClientApplicationId" + }, + { + "source": "OAuthClientAuthenticationType", + "target": "OAuthClientAuthenticationType" + }, + { + "source": "OAuthScopes", + "target": "OAuthScopes" + }, + { + "source": "OAuthTokenEndpointUrl", + "target": "OAuthTokenEndpointUrl" + } + ], + "operation": "CreateOAuthClientApplication", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::OAuthClientApplication", + "mappings": [ + { + "source": "OAuthClientApplicationId", + "target": "OAuthClientApplicationId" + } + ], + "operation": "DeleteOAuthClientApplication", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::RefreshSchedule", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSetId", + "target": "DataSetId" + } + ], + "operation": "CreateRefreshSchedule", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::RefreshSchedule", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DataSetId", + "target": "DataSetId" + } + ], + "operation": "DeleteRefreshSchedule", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Space", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SpaceId", + "target": "SpaceId" + } + ], + "operation": "CreateSpace", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Space", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "SpaceId", + "target": "SpaceId" + } + ], + "operation": "DeleteSpace", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Template", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "TemplateId", + "target": "TemplateId" + }, + { + "source": "VersionDescription", + "target": "VersionDescription" + } + ], + "operation": "CreateTemplate", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Template", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "TemplateId", + "target": "TemplateId" + } + ], + "operation": "DeleteTemplate", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Theme", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "BaseThemeId", + "target": "BaseThemeId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ThemeId", + "target": "ThemeId" + }, + { + "source": "VersionDescription", + "target": "VersionDescription" + } + ], + "operation": "CreateTheme", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::Theme", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "ThemeId", + "target": "ThemeId" + } + ], + "operation": "DeleteTheme", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::VPCConnection", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "DnsResolvers", + "target": "DnsResolvers" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "VPCConnectionId", + "target": "VPCConnectionId" + } + ], + "operation": "CreateVPCConnection", + "phase": "create", + "service": "quicksight" + }, + { + "cfn_type": "AWS::QuickSight::VPCConnection", + "mappings": [ + { + "source": "AwsAccountId", + "target": "AwsAccountId" + }, + { + "source": "VPCConnectionId", + "target": "VPCConnectionId" + } + ], + "operation": "DeleteVPCConnection", + "phase": "delete", + "service": "quicksight" + }, + { + "cfn_type": "AWS::RAM::Permission", + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "policyTemplate", + "target": "PolicyTemplate" + }, + { + "source": "resourceType", + "target": "ResourceType" + } + ], + "operation": "CreatePermission", + "phase": "create", + "service": "ram" + }, + { + "cfn_type": "AWS::RAM::Permission", + "mappings": [], + "operation": "DeletePermission", + "phase": "delete", + "service": "ram" + }, + { + "cfn_type": "AWS::RAM::ResourceShare", + "mappings": [ + { + "source": "allowExternalPrincipals", + "target": "AllowExternalPrincipals" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "permissionArns", + "target": "PermissionArns" + }, + { + "source": "principals", + "target": "Principals" + }, + { + "source": "resourceArns", + "target": "ResourceArns" + }, + { + "source": "sources", + "target": "Sources" + } + ], + "operation": "CreateResourceShare", + "phase": "create", + "service": "ram" + }, + { + "cfn_type": "AWS::RAM::ResourceShare", + "mappings": [], + "operation": "DeleteResourceShare", + "phase": "delete", + "service": "ram" + }, + { + "cfn_type": "AWS::RDS::CustomDBEngineVersion", + "mappings": [ + { + "source": "DatabaseInstallationFiles", + "target": "DatabaseInstallationFiles" + }, + { + "source": "DatabaseInstallationFilesS3BucketName", + "target": "DatabaseInstallationFilesS3BucketName" + }, + { + "source": "DatabaseInstallationFilesS3Prefix", + "target": "DatabaseInstallationFilesS3Prefix" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "ImageId", + "target": "ImageId" + }, + { + "source": "KMSKeyId", + "target": "KMSKeyId" + }, + { + "source": "Manifest", + "target": "Manifest" + }, + { + "source": "SourceCustomDbEngineVersionIdentifier", + "target": "SourceCustomDbEngineVersionIdentifier" + }, + { + "source": "UseAwsProvidedLatestImage", + "target": "UseAwsProvidedLatestImage" + } + ], + "operation": "CreateCustomDBEngineVersion", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::CustomDBEngineVersion", + "mappings": [ + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + } + ], + "operation": "DeleteCustomDBEngineVersion", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBCluster", + "mappings": [ + { + "source": "AllocatedStorage", + "target": "AllocatedStorage" + }, + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "AvailabilityZones", + "target": "AvailabilityZones" + }, + { + "source": "BacktrackWindow", + "target": "BacktrackWindow" + }, + { + "source": "BackupRetentionPeriod", + "target": "BackupRetentionPeriod" + }, + { + "source": "ClusterScalabilityType", + "target": "ClusterScalabilityType" + }, + { + "source": "CopyTagsToSnapshot", + "target": "CopyTagsToSnapshot" + }, + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + }, + { + "source": "DBClusterInstanceClass", + "target": "DBClusterInstanceClass" + }, + { + "source": "DBClusterParameterGroupName", + "target": "DBClusterParameterGroupName" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "DBSystemId", + "target": "DBSystemId" + }, + { + "source": "DatabaseInsightsMode", + "target": "DatabaseInsightsMode" + }, + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "DomainIAMRoleName", + "target": "DomainIAMRoleName" + }, + { + "source": "EnableCloudwatchLogsExports", + "target": "EnableCloudwatchLogsExports" + }, + { + "source": "EnableGlobalWriteForwarding", + "target": "EnableGlobalWriteForwarding" + }, + { + "source": "EnableHttpEndpoint", + "target": "EnableHttpEndpoint" + }, + { + "source": "EnableIAMDatabaseAuthentication", + "target": "EnableIAMDatabaseAuthentication" + }, + { + "source": "EnableLocalWriteForwarding", + "target": "EnableLocalWriteForwarding" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineLifecycleSupport", + "target": "EngineLifecycleSupport" + }, + { + "source": "EngineMode", + "target": "EngineMode" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + }, + { + "source": "Iops", + "target": "Iops" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "ManageMasterUserPassword", + "target": "ManageMasterUserPassword" + }, + { + "source": "MasterUserAuthenticationType", + "target": "MasterUserAuthenticationType" + }, + { + "source": "MasterUserPassword", + "target": "MasterUserPassword" + }, + { + "source": "MasterUsername", + "target": "MasterUsername" + }, + { + "source": "MonitoringInterval", + "target": "MonitoringInterval" + }, + { + "source": "MonitoringRoleArn", + "target": "MonitoringRoleArn" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "PerformanceInsightsKMSKeyId", + "target": "PerformanceInsightsKmsKeyId" + }, + { + "source": "PerformanceInsightsRetentionPeriod", + "target": "PerformanceInsightsRetentionPeriod" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "PreferredBackupWindow", + "target": "PreferredBackupWindow" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "ReplicationSourceIdentifier", + "target": "ReplicationSourceIdentifier" + }, + { + "source": "SourceRegion", + "target": "SourceRegion" + }, + { + "source": "StorageEncrypted", + "target": "StorageEncrypted" + }, + { + "source": "StorageType", + "target": "StorageType" + }, + { + "source": "VpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + } + ], + "operation": "CreateDBCluster", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBCluster", + "mappings": [ + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + }, + { + "source": "DeleteAutomatedBackups", + "target": "DeleteAutomatedBackups" + } + ], + "operation": "DeleteDBCluster", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBClusterParameterGroup", + "mappings": [ + { + "source": "DBClusterParameterGroupName", + "target": "DBClusterParameterGroupName" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateDBClusterParameterGroup", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBClusterParameterGroup", + "mappings": [ + { + "source": "DBClusterParameterGroupName", + "target": "DBClusterParameterGroupName" + } + ], + "operation": "DeleteDBClusterParameterGroup", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBInstance", + "mappings": [ + { + "source": "AutoMinorVersionUpgrade", + "target": "AutoMinorVersionUpgrade" + }, + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "BackupRetentionPeriod", + "target": "BackupRetentionPeriod" + }, + { + "source": "BackupTarget", + "target": "BackupTarget" + }, + { + "source": "CACertificateIdentifier", + "target": "CACertificateIdentifier" + }, + { + "source": "CharacterSetName", + "target": "CharacterSetName" + }, + { + "source": "CopyTagsToSnapshot", + "target": "CopyTagsToSnapshot" + }, + { + "source": "CustomIamInstanceProfile", + "target": "CustomIAMInstanceProfile" + }, + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + }, + { + "source": "DBInstanceClass", + "target": "DBInstanceClass" + }, + { + "source": "DBInstanceIdentifier", + "target": "DBInstanceIdentifier" + }, + { + "source": "DBName", + "target": "DBName" + }, + { + "source": "DBParameterGroupName", + "target": "DBParameterGroupName" + }, + { + "source": "DBSecurityGroups", + "target": "DBSecurityGroups" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "DBSystemId", + "target": "DBSystemId" + }, + { + "source": "DatabaseInsightsMode", + "target": "DatabaseInsightsMode" + }, + { + "source": "DedicatedLogVolume", + "target": "DedicatedLogVolume" + }, + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "DomainAuthSecretArn", + "target": "DomainAuthSecretArn" + }, + { + "source": "DomainDnsIps", + "target": "DomainDnsIps" + }, + { + "source": "DomainFqdn", + "target": "DomainFqdn" + }, + { + "source": "DomainIAMRoleName", + "target": "DomainIAMRoleName" + }, + { + "source": "DomainOu", + "target": "DomainOu" + }, + { + "source": "EnableCloudwatchLogsExports", + "target": "EnableCloudwatchLogsExports" + }, + { + "source": "EnableIAMDatabaseAuthentication", + "target": "EnableIAMDatabaseAuthentication" + }, + { + "source": "EnablePerformanceInsights", + "target": "EnablePerformanceInsights" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineLifecycleSupport", + "target": "EngineLifecycleSupport" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "Iops", + "target": "Iops" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "LicenseModel", + "target": "LicenseModel" + }, + { + "source": "ManageMasterUserPassword", + "target": "ManageMasterUserPassword" + }, + { + "source": "MasterUserAuthenticationType", + "target": "MasterUserAuthenticationType" + }, + { + "source": "MasterUserPassword", + "target": "MasterUserPassword" + }, + { + "source": "MasterUsername", + "target": "MasterUsername" + }, + { + "source": "MaxAllocatedStorage", + "target": "MaxAllocatedStorage" + }, + { + "source": "MonitoringInterval", + "target": "MonitoringInterval" + }, + { + "source": "MonitoringRoleArn", + "target": "MonitoringRoleArn" + }, + { + "source": "MultiAZ", + "target": "MultiAZ" + }, + { + "source": "NcharCharacterSetName", + "target": "NcharCharacterSetName" + }, + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "OptionGroupName", + "target": "OptionGroupName" + }, + { + "source": "PerformanceInsightsKMSKeyId", + "target": "PerformanceInsightsKMSKeyId" + }, + { + "source": "PerformanceInsightsRetentionPeriod", + "target": "PerformanceInsightsRetentionPeriod" + }, + { + "source": "PreferredBackupWindow", + "target": "PreferredBackupWindow" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "PromotionTier", + "target": "PromotionTier" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "StorageEncrypted", + "target": "StorageEncrypted" + }, + { + "source": "StorageThroughput", + "target": "StorageThroughput" + }, + { + "source": "StorageType", + "target": "StorageType" + }, + { + "source": "TdeCredentialArn", + "target": "TdeCredentialArn" + }, + { + "source": "TdeCredentialPassword", + "target": "TdeCredentialPassword" + }, + { + "source": "Timezone", + "target": "Timezone" + } + ], + "operation": "CreateDBInstance", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBInstance", + "mappings": [ + { + "source": "DBInstanceIdentifier", + "target": "DBInstanceIdentifier" + }, + { + "source": "DeleteAutomatedBackups", + "target": "DeleteAutomatedBackups" + } + ], + "operation": "DeleteDBInstance", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBParameterGroup", + "mappings": [ + { + "source": "DBParameterGroupName", + "target": "DBParameterGroupName" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateDBParameterGroup", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBParameterGroup", + "mappings": [ + { + "source": "DBParameterGroupName", + "target": "DBParameterGroupName" + } + ], + "operation": "DeleteDBParameterGroup", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBProxy", + "mappings": [ + { + "source": "DBProxyName", + "target": "DBProxyName" + }, + { + "source": "DebugLogging", + "target": "DebugLogging" + }, + { + "source": "DefaultAuthScheme", + "target": "DefaultAuthScheme" + }, + { + "source": "EndpointNetworkType", + "target": "EndpointNetworkType" + }, + { + "source": "EngineFamily", + "target": "EngineFamily" + }, + { + "source": "IdleClientTimeout", + "target": "IdleClientTimeout" + }, + { + "source": "RequireTLS", + "target": "RequireTLS" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "TargetConnectionNetworkType", + "target": "TargetConnectionNetworkType" + }, + { + "source": "VpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + }, + { + "source": "VpcSubnetIds", + "target": "VpcSubnetIds" + } + ], + "operation": "CreateDBProxy", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBProxy", + "mappings": [ + { + "source": "DBProxyName", + "target": "DBProxyName" + } + ], + "operation": "DeleteDBProxy", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBProxyEndpoint", + "mappings": [ + { + "source": "DBProxyEndpointName", + "target": "DBProxyEndpointName" + }, + { + "source": "DBProxyName", + "target": "DBProxyName" + }, + { + "source": "EndpointNetworkType", + "target": "EndpointNetworkType" + }, + { + "source": "TargetRole", + "target": "TargetRole" + }, + { + "source": "VpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + }, + { + "source": "VpcSubnetIds", + "target": "VpcSubnetIds" + } + ], + "operation": "CreateDBProxyEndpoint", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBProxyEndpoint", + "mappings": [ + { + "source": "DBProxyEndpointName", + "target": "DBProxyEndpointName" + } + ], + "operation": "DeleteDBProxyEndpoint", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBProxyTargetGroup", + "mappings": [ + { + "source": "DBClusterIdentifiers", + "target": "DBClusterIdentifiers" + }, + { + "source": "DBInstanceIdentifiers", + "target": "DBInstanceIdentifiers" + }, + { + "source": "DBProxyName", + "target": "DBProxyName" + }, + { + "source": "TargetGroupName", + "target": "TargetGroupName" + } + ], + "operation": "RegisterDBProxyTargets", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBProxyTargetGroup", + "mappings": [ + { + "source": "DBClusterIdentifiers", + "target": "DBClusterIdentifiers" + }, + { + "source": "DBInstanceIdentifiers", + "target": "DBInstanceIdentifiers" + }, + { + "source": "DBProxyName", + "target": "DBProxyName" + }, + { + "source": "TargetGroupName", + "target": "TargetGroupName" + } + ], + "operation": "DeregisterDBProxyTargets", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBShardGroup", + "mappings": [ + { + "source": "ComputeRedundancy", + "target": "ComputeRedundancy" + }, + { + "source": "DBClusterIdentifier", + "target": "DBClusterIdentifier" + }, + { + "source": "DBShardGroupIdentifier", + "target": "DBShardGroupIdentifier" + }, + { + "source": "MaxACU", + "target": "MaxACU" + }, + { + "source": "MinACU", + "target": "MinACU" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + } + ], + "operation": "CreateDBShardGroup", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBShardGroup", + "mappings": [ + { + "source": "DBShardGroupIdentifier", + "target": "DBShardGroupIdentifier" + } + ], + "operation": "DeleteDBShardGroup", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBSubnetGroup", + "mappings": [ + { + "source": "DBSubnetGroupDescription", + "target": "DBSubnetGroupDescription" + }, + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateDBSubnetGroup", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::DBSubnetGroup", + "mappings": [ + { + "source": "DBSubnetGroupName", + "target": "DBSubnetGroupName" + } + ], + "operation": "DeleteDBSubnetGroup", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::EventSubscription", + "mappings": [ + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "EventCategories", + "target": "EventCategories" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "SourceIds", + "target": "SourceIds" + }, + { + "source": "SourceType", + "target": "SourceType" + }, + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "CreateEventSubscription", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::EventSubscription", + "mappings": [ + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "DeleteEventSubscription", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::GlobalCluster", + "mappings": [ + { + "source": "DeletionProtection", + "target": "DeletionProtection" + }, + { + "source": "Engine", + "target": "Engine" + }, + { + "source": "EngineLifecycleSupport", + "target": "EngineLifecycleSupport" + }, + { + "source": "EngineVersion", + "target": "EngineVersion" + }, + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + }, + { + "source": "SourceDBClusterIdentifier", + "target": "SourceDBClusterIdentifier" + }, + { + "source": "StorageEncrypted", + "target": "StorageEncrypted" + } + ], + "operation": "CreateGlobalCluster", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::GlobalCluster", + "mappings": [ + { + "source": "GlobalClusterIdentifier", + "target": "GlobalClusterIdentifier" + } + ], + "operation": "DeleteGlobalCluster", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::Integration", + "mappings": [ + { + "source": "DataFilter", + "target": "DataFilter" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IntegrationName", + "target": "IntegrationName" + }, + { + "source": "KMSKeyId", + "target": "KMSKeyId" + }, + { + "source": "SourceArn", + "target": "SourceArn" + }, + { + "source": "TargetArn", + "target": "TargetArn" + } + ], + "operation": "CreateIntegration", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::Integration", + "mappings": [], + "operation": "DeleteIntegration", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::OptionGroup", + "mappings": [ + { + "source": "EngineName", + "target": "EngineName" + }, + { + "source": "MajorEngineVersion", + "target": "MajorEngineVersion" + }, + { + "source": "OptionGroupDescription", + "target": "OptionGroupDescription" + }, + { + "source": "OptionGroupName", + "target": "OptionGroupName" + } + ], + "operation": "CreateOptionGroup", + "phase": "create", + "service": "rds" + }, + { + "cfn_type": "AWS::RDS::OptionGroup", + "mappings": [ + { + "source": "OptionGroupName", + "target": "OptionGroupName" + } + ], + "operation": "DeleteOptionGroup", + "phase": "delete", + "service": "rds" + }, + { + "cfn_type": "AWS::RTBFabric::InboundExternalLink", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateInboundExternalLink", + "phase": "create", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::InboundExternalLink", + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + } + ], + "operation": "DeleteInboundExternalLink", + "phase": "delete", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::Link", + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + }, + { + "source": "httpResponderAllowed", + "target": "HttpResponderAllowed" + }, + { + "source": "peerGatewayId", + "target": "PeerGatewayId" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateLink", + "phase": "create", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::Link", + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + } + ], + "operation": "DeleteLink", + "phase": "delete", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::LinkRoutingRule", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + }, + { + "source": "linkId", + "target": "LinkId" + }, + { + "source": "priority", + "target": "Priority" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateLinkRoutingRule", + "phase": "create", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::LinkRoutingRule", + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + }, + { + "source": "linkId", + "target": "LinkId" + } + ], + "operation": "DeleteLinkRoutingRule", + "phase": "delete", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::OutboundExternalLink", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + }, + { + "source": "publicEndpoint", + "target": "PublicEndpoint" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateOutboundExternalLink", + "phase": "create", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::OutboundExternalLink", + "mappings": [ + { + "source": "gatewayId", + "target": "GatewayId" + } + ], + "operation": "DeleteOutboundExternalLink", + "phase": "delete", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::RequesterGateway", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreateRequesterGateway", + "phase": "create", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::RequesterGateway", + "mappings": [], + "operation": "DeleteRequesterGateway", + "phase": "delete", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::ResponderGateway", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "domainName", + "target": "DomainName" + }, + { + "source": "gatewayType", + "target": "GatewayType" + }, + { + "source": "port", + "target": "Port" + }, + { + "source": "protocol", + "target": "Protocol" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreateResponderGateway", + "phase": "create", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RTBFabric::ResponderGateway", + "mappings": [], + "operation": "DeleteResponderGateway", + "phase": "delete", + "service": "rtbfabric" + }, + { + "cfn_type": "AWS::RUM::AppMonitor", + "mappings": [ + { + "source": "CwLogEnabled", + "target": "CwLogEnabled" + }, + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "DomainList", + "target": "DomainList" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Platform", + "target": "Platform" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateAppMonitor", + "phase": "create", + "service": "rum" + }, + { + "cfn_type": "AWS::RUM::AppMonitor", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteAppMonitor", + "phase": "delete", + "service": "rum" + }, + { + "cfn_type": "AWS::Rbin::Rule", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "ResourceType", + "target": "ResourceType" + } + ], + "operation": "CreateRule", + "phase": "create", + "service": "rbin" + }, + { + "cfn_type": "AWS::Rbin::Rule", + "mappings": [], + "operation": "DeleteRule", + "phase": "delete", + "service": "rbin" + }, + { + "cfn_type": "AWS::Redshift::Cluster", + "mappings": [ + { + "source": "AllowVersionUpgrade", + "target": "AllowVersionUpgrade" + }, + { + "source": "AquaConfigurationStatus", + "target": "AquaConfigurationStatus" + }, + { + "source": "AutomatedSnapshotRetentionPeriod", + "target": "AutomatedSnapshotRetentionPeriod" + }, + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "AvailabilityZoneRelocation", + "target": "AvailabilityZoneRelocation" + }, + { + "source": "ClusterIdentifier", + "target": "ClusterIdentifier" + }, + { + "source": "ClusterParameterGroupName", + "target": "ClusterParameterGroupName" + }, + { + "source": "ClusterSecurityGroups", + "target": "ClusterSecurityGroups" + }, + { + "source": "ClusterSubnetGroupName", + "target": "ClusterSubnetGroupName" + }, + { + "source": "ClusterType", + "target": "ClusterType" + }, + { + "source": "ClusterVersion", + "target": "ClusterVersion" + }, + { + "source": "DBName", + "target": "DBName" + }, + { + "source": "ElasticIp", + "target": "ElasticIp" + }, + { + "source": "Encrypted", + "target": "Encrypted" + }, + { + "source": "EnhancedVpcRouting", + "target": "EnhancedVpcRouting" + }, + { + "source": "HsmClientCertificateIdentifier", + "target": "HsmClientCertificateIdentifier" + }, + { + "source": "HsmConfigurationIdentifier", + "target": "HsmConfigurationIdentifier" + }, + { + "source": "IamRoles", + "target": "IamRoles" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "MaintenanceTrackName", + "target": "MaintenanceTrackName" + }, + { + "source": "ManageMasterPassword", + "target": "ManageMasterPassword" + }, + { + "source": "ManualSnapshotRetentionPeriod", + "target": "ManualSnapshotRetentionPeriod" + }, + { + "source": "MasterPasswordSecretKmsKeyId", + "target": "MasterPasswordSecretKmsKeyId" + }, + { + "source": "MasterUserPassword", + "target": "MasterUserPassword" + }, + { + "source": "MasterUsername", + "target": "MasterUsername" + }, + { + "source": "MultiAZ", + "target": "MultiAZ" + }, + { + "source": "NodeType", + "target": "NodeType" + }, + { + "source": "NumberOfNodes", + "target": "NumberOfNodes" + }, + { + "source": "Port", + "target": "Port" + }, + { + "source": "PreferredMaintenanceWindow", + "target": "PreferredMaintenanceWindow" + }, + { + "source": "PubliclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "VpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::Cluster", + "mappings": [ + { + "source": "ClusterIdentifier", + "target": "ClusterIdentifier" + } + ], + "operation": "DeleteCluster", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::ClusterParameterGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "ParameterGroupFamily", + "target": "ParameterGroupFamily" + }, + { + "source": "ParameterGroupName", + "target": "ParameterGroupName" + } + ], + "operation": "CreateClusterParameterGroup", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::ClusterParameterGroup", + "mappings": [ + { + "source": "ParameterGroupName", + "target": "ParameterGroupName" + } + ], + "operation": "DeleteClusterParameterGroup", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::ClusterSubnetGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + } + ], + "operation": "CreateClusterSubnetGroup", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::ClusterSubnetGroup", + "mappings": [], + "operation": "DeleteClusterSubnetGroup", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::EndpointAccess", + "mappings": [ + { + "source": "ClusterIdentifier", + "target": "ClusterIdentifier" + }, + { + "source": "EndpointName", + "target": "EndpointName" + }, + { + "source": "ResourceOwner", + "target": "ResourceOwner" + }, + { + "source": "SubnetGroupName", + "target": "SubnetGroupName" + }, + { + "source": "VpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + } + ], + "operation": "CreateEndpointAccess", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::EndpointAccess", + "mappings": [ + { + "source": "EndpointName", + "target": "EndpointName" + } + ], + "operation": "DeleteEndpointAccess", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::EventSubscription", + "mappings": [ + { + "source": "Enabled", + "target": "Enabled" + }, + { + "source": "EventCategories", + "target": "EventCategories" + }, + { + "source": "Severity", + "target": "Severity" + }, + { + "source": "SnsTopicArn", + "target": "SnsTopicArn" + }, + { + "source": "SourceIds", + "target": "SourceIds" + }, + { + "source": "SourceType", + "target": "SourceType" + }, + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "CreateEventSubscription", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::EventSubscription", + "mappings": [ + { + "source": "SubscriptionName", + "target": "SubscriptionName" + } + ], + "operation": "DeleteEventSubscription", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::Integration", + "mappings": [ + { + "source": "IntegrationName", + "target": "IntegrationName" + }, + { + "source": "KMSKeyId", + "target": "KMSKeyId" + }, + { + "source": "SourceArn", + "target": "SourceArn" + }, + { + "source": "TargetArn", + "target": "TargetArn" + } + ], + "operation": "CreateIntegration", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::Integration", + "mappings": [], + "operation": "DeleteIntegration", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::ScheduledAction", + "mappings": [ + { + "source": "Enable", + "target": "Enable" + }, + { + "source": "IamRole", + "target": "IamRole" + }, + { + "source": "Schedule", + "target": "Schedule" + }, + { + "source": "ScheduledActionDescription", + "target": "ScheduledActionDescription" + }, + { + "source": "ScheduledActionName", + "target": "ScheduledActionName" + } + ], + "operation": "CreateScheduledAction", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::ScheduledAction", + "mappings": [ + { + "source": "ScheduledActionName", + "target": "ScheduledActionName" + } + ], + "operation": "DeleteScheduledAction", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::SnapshotSchedule", + "ignored_inputs": [ + "DryRun" + ], + "mappings": [ + { + "source": "ScheduleDefinitions", + "target": "ScheduleDefinitions" + }, + { + "source": "ScheduleDescription", + "target": "ScheduleDescription" + }, + { + "source": "ScheduleIdentifier", + "target": "ScheduleIdentifier" + } + ], + "operation": "CreateSnapshotSchedule", + "phase": "create", + "service": "redshift" + }, + { + "cfn_type": "AWS::Redshift::SnapshotSchedule", + "mappings": [ + { + "source": "ScheduleIdentifier", + "target": "ScheduleIdentifier" + } + ], + "operation": "DeleteSnapshotSchedule", + "phase": "delete", + "service": "redshift" + }, + { + "cfn_type": "AWS::RedshiftServerless::Namespace", + "mappings": [ + { + "source": "adminPasswordSecretKmsKeyId", + "target": "AdminPasswordSecretKmsKeyId" + }, + { + "source": "adminUserPassword", + "target": "AdminUserPassword" + }, + { + "source": "adminUsername", + "target": "AdminUsername" + }, + { + "source": "dbName", + "target": "DbName" + }, + { + "source": "defaultIamRoleArn", + "target": "DefaultIamRoleArn" + }, + { + "source": "iamRoles", + "target": "IamRoles" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "logExports", + "target": "LogExports" + }, + { + "source": "manageAdminPassword", + "target": "ManageAdminPassword" + }, + { + "source": "namespaceName", + "target": "NamespaceName" + }, + { + "source": "redshiftIdcApplicationArn", + "target": "RedshiftIdcApplicationArn" + } + ], + "operation": "CreateNamespace", + "phase": "create", + "service": "redshift-serverless" + }, + { + "cfn_type": "AWS::RedshiftServerless::Namespace", + "mappings": [ + { + "source": "finalSnapshotName", + "target": "FinalSnapshotName" + }, + { + "source": "finalSnapshotRetentionPeriod", + "target": "FinalSnapshotRetentionPeriod" + }, + { + "source": "namespaceName", + "target": "NamespaceName" + } + ], + "operation": "DeleteNamespace", + "phase": "delete", + "service": "redshift-serverless" + }, + { + "cfn_type": "AWS::RedshiftServerless::Snapshot", + "mappings": [ + { + "source": "namespaceName", + "target": "NamespaceName" + }, + { + "source": "retentionPeriod", + "target": "RetentionPeriod" + }, + { + "source": "snapshotName", + "target": "SnapshotName" + } + ], + "operation": "CreateSnapshot", + "phase": "create", + "service": "redshift-serverless" + }, + { + "cfn_type": "AWS::RedshiftServerless::Snapshot", + "mappings": [ + { + "source": "snapshotName", + "target": "SnapshotName" + } + ], + "operation": "DeleteSnapshot", + "phase": "delete", + "service": "redshift-serverless" + }, + { + "cfn_type": "AWS::RedshiftServerless::Workgroup", + "mappings": [ + { + "source": "baseCapacity", + "target": "BaseCapacity" + }, + { + "source": "enhancedVpcRouting", + "target": "EnhancedVpcRouting" + }, + { + "source": "maxCapacity", + "target": "MaxCapacity" + }, + { + "source": "namespaceName", + "target": "NamespaceName" + }, + { + "source": "port", + "target": "Port" + }, + { + "source": "publiclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "trackName", + "target": "TrackName" + }, + { + "source": "workgroupName", + "target": "WorkgroupName" + } + ], + "operation": "CreateWorkgroup", + "phase": "create", + "service": "redshift-serverless" + }, + { + "cfn_type": "AWS::RedshiftServerless::Workgroup", + "mappings": [ + { + "source": "workgroupName", + "target": "WorkgroupName" + } + ], + "operation": "DeleteWorkgroup", + "phase": "delete", + "service": "redshift-serverless" + }, + { + "cfn_type": "AWS::RefactorSpaces::Application", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ProxyType", + "target": "ProxyType" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Application", + "mappings": [ + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + } + ], + "operation": "DeleteApplication", + "phase": "delete", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Environment", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NetworkFabricType", + "target": "NetworkFabricType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Environment", + "mappings": [], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Route", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "RouteType", + "target": "RouteType" + }, + { + "source": "ServiceIdentifier", + "target": "ServiceIdentifier" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRoute", + "phase": "create", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Route", + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + } + ], + "operation": "DeleteRoute", + "phase": "delete", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Service", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EndpointType", + "target": "EndpointType" + }, + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateService", + "phase": "create", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::RefactorSpaces::Service", + "mappings": [ + { + "source": "ApplicationIdentifier", + "target": "ApplicationIdentifier" + }, + { + "source": "EnvironmentIdentifier", + "target": "EnvironmentIdentifier" + } + ], + "operation": "DeleteService", + "phase": "delete", + "service": "migration-hub-refactor-spaces" + }, + { + "cfn_type": "AWS::Rekognition::Collection", + "mappings": [ + { + "source": "CollectionId", + "target": "CollectionId" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCollection", + "phase": "create", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::Collection", + "mappings": [ + { + "source": "CollectionId", + "target": "CollectionId" + } + ], + "operation": "DeleteCollection", + "phase": "delete", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::Dataset", + "mappings": [ + { + "source": "DatasetType", + "target": "DatasetType" + }, + { + "source": "ProjectArn", + "target": "ProjectArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateDataset", + "phase": "create", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::Dataset", + "mappings": [], + "operation": "DeleteDataset", + "phase": "delete", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::Project", + "mappings": [ + { + "source": "ProjectName", + "target": "ProjectName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateProject", + "phase": "create", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::Project", + "mappings": [], + "operation": "DeleteProject", + "phase": "delete", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::StreamProcessor", + "mappings": [ + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateStreamProcessor", + "phase": "create", + "service": "rekognition" + }, + { + "cfn_type": "AWS::Rekognition::StreamProcessor", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteStreamProcessor", + "phase": "delete", + "service": "rekognition" + }, + { + "cfn_type": "AWS::ResilienceHub::App", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateApp", + "phase": "create", + "service": "resiliencehub" + }, + { + "cfn_type": "AWS::ResilienceHub::App", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteApp", + "phase": "delete", + "service": "resiliencehub" + }, + { + "cfn_type": "AWS::ResilienceHub::ResiliencyPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "dataLocationConstraint", + "target": "DataLocationConstraint" + }, + { + "source": "policyDescription", + "target": "PolicyDescription" + }, + { + "source": "policyName", + "target": "PolicyName" + }, + { + "source": "tier", + "target": "Tier" + } + ], + "operation": "CreateResiliencyPolicy", + "phase": "create", + "service": "resiliencehub" + }, + { + "cfn_type": "AWS::ResilienceHub::ResiliencyPolicy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteResiliencyPolicy", + "phase": "delete", + "service": "resiliencehub" + }, + { + "cfn_type": "AWS::ResilienceHubV2::Policy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePolicy", + "phase": "create", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::Policy", + "mappings": [], + "operation": "DeletePolicy", + "phase": "delete", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::Service", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "dependencyDiscovery", + "target": "DependencyDiscovery" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policyArn", + "target": "PolicyArn" + }, + { + "source": "regions", + "target": "Regions" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateService", + "phase": "create", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::Service", + "mappings": [], + "operation": "DeleteService", + "phase": "delete", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::ServiceFunction", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "criticality", + "target": "Criticality" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "serviceArn", + "target": "ServiceArn" + } + ], + "operation": "CreateServiceFunction", + "phase": "create", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::ServiceFunction", + "mappings": [ + { + "source": "serviceArn", + "target": "ServiceArn" + } + ], + "operation": "DeleteServiceFunction", + "phase": "delete", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::System", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "sharingEnabled", + "target": "SharingEnabled" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateSystem", + "phase": "create", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::System", + "mappings": [], + "operation": "DeleteSystem", + "phase": "delete", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::UserJourney", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policyArn", + "target": "PolicyArn" + } + ], + "operation": "CreateUserJourney", + "phase": "create", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResilienceHubV2::UserJourney", + "mappings": [], + "operation": "DeleteUserJourney", + "phase": "delete", + "service": "resiliencehubv2" + }, + { + "cfn_type": "AWS::ResourceExplorer2::Index", + "mappings": [], + "operation": "DeleteIndex", + "phase": "delete", + "service": "resource-explorer-2" + }, + { + "cfn_type": "AWS::ResourceExplorer2::View", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Scope", + "target": "Scope" + }, + { + "source": "ViewName", + "target": "ViewName" + } + ], + "operation": "CreateView", + "phase": "create", + "service": "resource-explorer-2" + }, + { + "cfn_type": "AWS::ResourceExplorer2::View", + "mappings": [], + "operation": "DeleteView", + "phase": "delete", + "service": "resource-explorer-2" + }, + { + "cfn_type": "AWS::ResourceGroups::Group", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateGroup", + "phase": "create", + "service": "resource-groups" + }, + { + "cfn_type": "AWS::ResourceGroups::Group", + "mappings": [], + "operation": "DeleteGroup", + "phase": "delete", + "service": "resource-groups" + }, + { + "cfn_type": "AWS::ResourceGroups::TagSyncTask", + "mappings": [ + { + "source": "Group", + "target": "Group" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "TagKey", + "target": "TagKey" + }, + { + "source": "TagValue", + "target": "TagValue" + } + ], + "operation": "StartTagSyncTask", + "phase": "create", + "service": "resource-groups" + }, + { + "cfn_type": "AWS::ResourceGroups::TagSyncTask", + "mappings": [], + "operation": "CancelTagSyncTask", + "phase": "delete", + "service": "resource-groups" + }, + { + "cfn_type": "AWS::RolesAnywhere::CRL", + "mappings": [ + { + "source": "enabled", + "target": "Enabled" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "trustAnchorArn", + "target": "TrustAnchorArn" + } + ], + "operation": "ImportCrl", + "phase": "create", + "service": "rolesanywhere" + }, + { + "cfn_type": "AWS::RolesAnywhere::CRL", + "mappings": [], + "operation": "DeleteCrl", + "phase": "delete", + "service": "rolesanywhere" + }, + { + "cfn_type": "AWS::RolesAnywhere::Profile", + "mappings": [ + { + "source": "acceptRoleSessionName", + "target": "AcceptRoleSessionName" + }, + { + "source": "durationSeconds", + "target": "DurationSeconds" + }, + { + "source": "enabled", + "target": "Enabled" + }, + { + "source": "managedPolicyArns", + "target": "ManagedPolicyArns" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "requireInstanceProperties", + "target": "RequireInstanceProperties" + }, + { + "source": "roleArns", + "target": "RoleArns" + }, + { + "source": "sessionPolicy", + "target": "SessionPolicy" + } + ], + "operation": "CreateProfile", + "phase": "create", + "service": "rolesanywhere" + }, + { + "cfn_type": "AWS::RolesAnywhere::Profile", + "mappings": [], + "operation": "DeleteProfile", + "phase": "delete", + "service": "rolesanywhere" + }, + { + "cfn_type": "AWS::RolesAnywhere::TrustAnchor", + "mappings": [ + { + "source": "enabled", + "target": "Enabled" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateTrustAnchor", + "phase": "create", + "service": "rolesanywhere" + }, + { + "cfn_type": "AWS::RolesAnywhere::TrustAnchor", + "mappings": [], + "operation": "DeleteTrustAnchor", + "phase": "delete", + "service": "rolesanywhere" + }, + { + "cfn_type": "AWS::Route53::CidrCollection", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateCidrCollection", + "phase": "create", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::CidrCollection", + "mappings": [], + "operation": "DeleteCidrCollection", + "phase": "delete", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::DNSSEC", + "mappings": [ + { + "source": "HostedZoneId", + "target": "HostedZoneId" + } + ], + "operation": "EnableHostedZoneDNSSEC", + "phase": "create", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::HealthCheck", + "mappings": [], + "operation": "DeleteHealthCheck", + "phase": "delete", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::HostedZone", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateHostedZone", + "phase": "create", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::HostedZone", + "mappings": [], + "operation": "DeleteHostedZone", + "phase": "delete", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::KeySigningKey", + "mappings": [ + { + "source": "HostedZoneId", + "target": "HostedZoneId" + }, + { + "source": "KeyManagementServiceArn", + "target": "KeyManagementServiceArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Status", + "target": "Status" + } + ], + "operation": "CreateKeySigningKey", + "phase": "create", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53::KeySigningKey", + "mappings": [ + { + "source": "HostedZoneId", + "target": "HostedZoneId" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteKeySigningKey", + "phase": "delete", + "service": "route53" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::AccessSource", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "cidr", + "target": "Cidr" + }, + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "dnsViewId", + "target": "DnsViewId" + }, + { + "source": "ipAddressType", + "target": "IpAddressType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "protocol", + "target": "Protocol" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAccessSource", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::AccessSource", + "mappings": [], + "operation": "DeleteAccessSource", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::AccessToken", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "dnsViewId", + "target": "DnsViewId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAccessToken", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::AccessToken", + "mappings": [], + "operation": "DeleteAccessToken", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::DnsView", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "dnssecValidation", + "target": "DnssecValidation" + }, + { + "source": "ednsClientSubnet", + "target": "EdnsClientSubnet" + }, + { + "source": "firewallRulesFailOpen", + "target": "FirewallRulesFailOpen" + }, + { + "source": "globalResolverId", + "target": "GlobalResolverId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDNSView", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::DnsView", + "mappings": [], + "operation": "DeleteDNSView", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::FirewallDomainList", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "globalResolverId", + "target": "GlobalResolverId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateFirewallDomainList", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::FirewallDomainList", + "mappings": [], + "operation": "DeleteFirewallDomainList", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::FirewallRule", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "action", + "target": "Action" + }, + { + "source": "blockOverrideDnsType", + "target": "BlockOverrideDnsType" + }, + { + "source": "blockOverrideDomain", + "target": "BlockOverrideDomain" + }, + { + "source": "blockOverrideTtl", + "target": "BlockOverrideTtl" + }, + { + "source": "blockResponse", + "target": "BlockResponse" + }, + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "confidenceThreshold", + "target": "ConfidenceThreshold" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "dnsAdvancedProtection", + "target": "DnsAdvancedProtection" + }, + { + "source": "dnsViewId", + "target": "DnsViewId" + }, + { + "source": "firewallDomainListId", + "target": "FirewallDomainListId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "priority", + "target": "Priority" + }, + { + "source": "qType", + "target": "QType" + } + ], + "operation": "CreateFirewallRule", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::FirewallRule", + "mappings": [], + "operation": "DeleteFirewallRule", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::GlobalResolver", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "ipAddressType", + "target": "IpAddressType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "observabilityRegion", + "target": "ObservabilityRegion" + }, + { + "source": "regions", + "target": "Regions" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateGlobalResolver", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::GlobalResolver", + "mappings": [], + "operation": "DeleteGlobalResolver", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::HostedZoneAssociation", + "mappings": [ + { + "source": "hostedZoneId", + "target": "HostedZoneId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "AssociateHostedZone", + "phase": "create", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53GlobalResolver::HostedZoneAssociation", + "mappings": [ + { + "source": "hostedZoneId", + "target": "HostedZoneId" + }, + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "DisassociateHostedZone", + "phase": "delete", + "service": "route53globalresolver" + }, + { + "cfn_type": "AWS::Route53Profiles::Profile", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateProfile", + "phase": "create", + "service": "route53profiles" + }, + { + "cfn_type": "AWS::Route53Profiles::Profile", + "mappings": [], + "operation": "DeleteProfile", + "phase": "delete", + "service": "route53profiles" + }, + { + "cfn_type": "AWS::Route53Profiles::ProfileAssociation", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "ProfileId", + "target": "ProfileId" + }, + { + "source": "ResourceId", + "target": "ResourceId" + } + ], + "operation": "AssociateProfile", + "phase": "create", + "service": "route53profiles" + }, + { + "cfn_type": "AWS::Route53Profiles::ProfileAssociation", + "mappings": [ + { + "source": "ProfileId", + "target": "ProfileId" + }, + { + "source": "ResourceId", + "target": "ResourceId" + } + ], + "operation": "DisassociateProfile", + "phase": "delete", + "service": "route53profiles" + }, + { + "cfn_type": "AWS::Route53Profiles::ProfileResourceAssociation", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "ProfileId", + "target": "ProfileId" + }, + { + "source": "ResourceArn", + "target": "ResourceArn" + }, + { + "source": "ResourceProperties", + "target": "ResourceProperties" + } + ], + "operation": "AssociateResourceToProfile", + "phase": "create", + "service": "route53profiles" + }, + { + "cfn_type": "AWS::Route53Profiles::ProfileResourceAssociation", + "mappings": [ + { + "source": "ProfileId", + "target": "ProfileId" + }, + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "DisassociateResourceFromProfile", + "phase": "delete", + "service": "route53profiles" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::Cluster", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "NetworkType", + "target": "NetworkType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::Cluster", + "mappings": [], + "operation": "DeleteCluster", + "phase": "delete", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::ControlPanel", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateControlPanel", + "phase": "create", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::ControlPanel", + "mappings": [], + "operation": "DeleteControlPanel", + "phase": "delete", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::RoutingControl", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClusterArn", + "target": "ClusterArn" + }, + { + "source": "ControlPanelArn", + "target": "ControlPanelArn" + } + ], + "operation": "CreateRoutingControl", + "phase": "create", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::RoutingControl", + "mappings": [], + "operation": "DeleteRoutingControl", + "phase": "delete", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::SafetyRule", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateSafetyRule", + "phase": "create", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryControl::SafetyRule", + "mappings": [], + "operation": "DeleteSafetyRule", + "phase": "delete", + "service": "route53-recovery-control-config" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::Cell", + "mappings": [ + { + "source": "CellName", + "target": "CellName" + }, + { + "source": "Cells", + "target": "Cells" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCell", + "phase": "create", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::Cell", + "mappings": [ + { + "source": "CellName", + "target": "CellName" + } + ], + "operation": "DeleteCell", + "phase": "delete", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::ReadinessCheck", + "mappings": [ + { + "source": "ReadinessCheckName", + "target": "ReadinessCheckName" + }, + { + "source": "ResourceSetName", + "target": "ResourceSetName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateReadinessCheck", + "phase": "create", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::ReadinessCheck", + "mappings": [ + { + "source": "ReadinessCheckName", + "target": "ReadinessCheckName" + } + ], + "operation": "DeleteReadinessCheck", + "phase": "delete", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::RecoveryGroup", + "mappings": [ + { + "source": "Cells", + "target": "Cells" + }, + { + "source": "RecoveryGroupName", + "target": "RecoveryGroupName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateRecoveryGroup", + "phase": "create", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::RecoveryGroup", + "mappings": [ + { + "source": "RecoveryGroupName", + "target": "RecoveryGroupName" + } + ], + "operation": "DeleteRecoveryGroup", + "phase": "delete", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::ResourceSet", + "mappings": [ + { + "source": "ResourceSetName", + "target": "ResourceSetName" + }, + { + "source": "ResourceSetType", + "target": "ResourceSetType" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateResourceSet", + "phase": "create", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53RecoveryReadiness::ResourceSet", + "mappings": [ + { + "source": "ResourceSetName", + "target": "ResourceSetName" + } + ], + "operation": "DeleteResourceSet", + "phase": "delete", + "service": "route53-recovery-readiness" + }, + { + "cfn_type": "AWS::Route53Resolver::FirewallDomainList", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateFirewallDomainList", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::FirewallDomainList", + "mappings": [], + "operation": "DeleteFirewallDomainList", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::FirewallRuleGroup", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateFirewallRuleGroup", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::FirewallRuleGroup", + "mappings": [], + "operation": "DeleteFirewallRuleGroup", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::FirewallRuleGroupAssociation", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "FirewallRuleGroupId", + "target": "FirewallRuleGroupId" + }, + { + "source": "MutationProtection", + "target": "MutationProtection" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Priority", + "target": "Priority" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "AssociateFirewallRuleGroup", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::OutpostResolver", + "mappings": [ + { + "source": "InstanceCount", + "target": "InstanceCount" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OutpostArn", + "target": "OutpostArn" + }, + { + "source": "PreferredInstanceType", + "target": "PreferredInstanceType" + } + ], + "operation": "CreateOutpostResolver", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::OutpostResolver", + "mappings": [], + "operation": "DeleteOutpostResolver", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverEndpoint", + "mappings": [ + { + "source": "Direction", + "target": "Direction" + }, + { + "source": "Dns64Enabled", + "target": "Dns64Enabled" + }, + { + "source": "Ipv6InternetAccessEnabled", + "target": "Ipv6InternetAccessEnabled" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OutpostArn", + "target": "OutpostArn" + }, + { + "source": "PreferredInstanceType", + "target": "PreferredInstanceType" + }, + { + "source": "Protocols", + "target": "Protocols" + }, + { + "source": "ResolverEndpointType", + "target": "ResolverEndpointType" + }, + { + "source": "RniEnhancedMetricsEnabled", + "target": "RniEnhancedMetricsEnabled" + }, + { + "source": "SecurityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "TargetNameServerMetricsEnabled", + "target": "TargetNameServerMetricsEnabled" + } + ], + "operation": "CreateResolverEndpoint", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverEndpoint", + "mappings": [], + "operation": "DeleteResolverEndpoint", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverQueryLoggingConfig", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "DestinationArn", + "target": "DestinationArn" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateResolverQueryLogConfig", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverQueryLoggingConfigAssociation", + "mappings": [ + { + "source": "ResolverQueryLogConfigId", + "target": "ResolverQueryLogConfigId" + }, + { + "source": "ResourceId", + "target": "ResourceId" + } + ], + "operation": "AssociateResolverQueryLogConfig", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverQueryLoggingConfigAssociation", + "mappings": [ + { + "source": "ResolverQueryLogConfigId", + "target": "ResolverQueryLogConfigId" + }, + { + "source": "ResourceId", + "target": "ResourceId" + } + ], + "operation": "DisassociateResolverQueryLogConfig", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverRule", + "mappings": [ + { + "source": "DelegationRecord", + "target": "DelegationRecord" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ResolverEndpointId", + "target": "ResolverEndpointId" + }, + { + "source": "RuleType", + "target": "RuleType" + } + ], + "operation": "CreateResolverRule", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverRule", + "mappings": [], + "operation": "DeleteResolverRule", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverRuleAssociation", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "ResolverRuleId", + "target": "ResolverRuleId" + }, + { + "source": "VPCId", + "target": "VPCId" + } + ], + "operation": "AssociateResolverRule", + "phase": "create", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::Route53Resolver::ResolverRuleAssociation", + "mappings": [ + { + "source": "ResolverRuleId", + "target": "ResolverRuleId" + }, + { + "source": "VPCId", + "target": "VPCId" + } + ], + "operation": "DisassociateResolverRule", + "phase": "delete", + "service": "route53resolver" + }, + { + "cfn_type": "AWS::S3::AccessGrant", + "mappings": [ + { + "source": "AccessGrantsLocationId", + "target": "AccessGrantsLocationId" + }, + { + "source": "ApplicationArn", + "target": "ApplicationArn" + }, + { + "source": "Permission", + "target": "Permission" + }, + { + "source": "S3PrefixType", + "target": "S3PrefixType" + } + ], + "operation": "CreateAccessGrant", + "phase": "create", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::AccessGrant", + "mappings": [], + "operation": "DeleteAccessGrant", + "phase": "delete", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::AccessGrantsInstance", + "mappings": [ + { + "source": "IdentityCenterArn", + "target": "IdentityCenterArn" + } + ], + "operation": "CreateAccessGrantsInstance", + "phase": "create", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::AccessGrantsInstance", + "mappings": [], + "operation": "DeleteAccessGrantsInstance", + "phase": "delete", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::AccessGrantsLocation", + "mappings": [ + { + "source": "IAMRoleArn", + "target": "IamRoleArn" + }, + { + "source": "LocationScope", + "target": "LocationScope" + } + ], + "operation": "CreateAccessGrantsLocation", + "phase": "create", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::AccessGrantsLocation", + "mappings": [], + "operation": "DeleteAccessGrantsLocation", + "phase": "delete", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::Bucket", + "mappings": [ + { + "source": "Bucket", + "target": "BucketName" + }, + { + "source": "BucketNamespace", + "target": "BucketNamespace" + } + ], + "operation": "CreateBucket", + "phase": "create", + "service": "s3" + }, + { + "cfn_type": "AWS::S3::Bucket", + "mappings": [ + { + "source": "Bucket", + "target": "BucketName" + } + ], + "operation": "DeleteBucket", + "phase": "delete", + "service": "s3" + }, + { + "cfn_type": "AWS::S3::BucketPolicy", + "mappings": [ + { + "source": "Bucket", + "target": "Bucket" + } + ], + "operation": "PutBucketPolicy", + "phase": "create", + "service": "s3" + }, + { + "cfn_type": "AWS::S3::BucketPolicy", + "mappings": [ + { + "source": "Bucket", + "target": "Bucket" + } + ], + "operation": "DeleteBucketPolicy", + "phase": "delete", + "service": "s3" + }, + { + "cfn_type": "AWS::S3::MultiRegionAccessPoint", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [], + "operation": "DeleteMultiRegionAccessPoint", + "phase": "delete", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3::StorageLensGroup", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteStorageLensGroup", + "phase": "delete", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3Files::AccessPoint", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "fileSystemId", + "target": "FileSystemId" + } + ], + "operation": "CreateAccessPoint", + "phase": "create", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::AccessPoint", + "mappings": [], + "operation": "DeleteAccessPoint", + "phase": "delete", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::FileSystem", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "acceptBucketWarning", + "target": "AcceptBucketWarning" + }, + { + "source": "bucket", + "target": "Bucket" + }, + { + "source": "clientToken", + "target": "ClientToken" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "prefix", + "target": "Prefix" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateFileSystem", + "phase": "create", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::FileSystem", + "mappings": [], + "operation": "DeleteFileSystem", + "phase": "delete", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::FileSystemPolicy", + "mappings": [ + { + "source": "fileSystemId", + "target": "FileSystemId" + } + ], + "operation": "PutFileSystemPolicy", + "phase": "create", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::FileSystemPolicy", + "mappings": [ + { + "source": "fileSystemId", + "target": "FileSystemId" + } + ], + "operation": "DeleteFileSystemPolicy", + "phase": "delete", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::MountTarget", + "mappings": [ + { + "source": "fileSystemId", + "target": "FileSystemId" + }, + { + "source": "ipAddressType", + "target": "IpAddressType" + }, + { + "source": "ipv4Address", + "target": "Ipv4Address" + }, + { + "source": "ipv6Address", + "target": "Ipv6Address" + }, + { + "source": "securityGroups", + "target": "SecurityGroups" + }, + { + "source": "subnetId", + "target": "SubnetId" + } + ], + "operation": "CreateMountTarget", + "phase": "create", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Files::MountTarget", + "mappings": [], + "operation": "DeleteMountTarget", + "phase": "delete", + "service": "s3files" + }, + { + "cfn_type": "AWS::S3Outposts::Bucket", + "mappings": [ + { + "source": "Bucket", + "target": "BucketName" + }, + { + "source": "OutpostId", + "target": "OutpostId" + } + ], + "operation": "CreateBucket", + "phase": "create", + "service": "s3control" + }, + { + "cfn_type": "AWS::S3Outposts::Endpoint", + "mappings": [ + { + "source": "AccessType", + "target": "AccessType" + }, + { + "source": "CustomerOwnedIpv4Pool", + "target": "CustomerOwnedIpv4Pool" + }, + { + "source": "OutpostId", + "target": "OutpostId" + }, + { + "source": "SecurityGroupId", + "target": "SecurityGroupId" + }, + { + "source": "SubnetId", + "target": "SubnetId" + } + ], + "operation": "CreateEndpoint", + "phase": "create", + "service": "s3outposts" + }, + { + "cfn_type": "AWS::S3Outposts::Endpoint", + "mappings": [ + { + "source": "OutpostId", + "target": "OutpostId" + } + ], + "operation": "DeleteEndpoint", + "phase": "delete", + "service": "s3outposts" + }, + { + "cfn_type": "AWS::S3Tables::Namespace", + "mappings": [ + { + "source": "tableBucketARN", + "target": "TableBucketARN" + } + ], + "operation": "CreateNamespace", + "phase": "create", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::Namespace", + "mappings": [ + { + "source": "namespace", + "target": "Namespace" + }, + { + "source": "tableBucketARN", + "target": "TableBucketARN" + } + ], + "operation": "DeleteNamespace", + "phase": "delete", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::Table", + "mappings": [ + { + "source": "name", + "target": "TableName" + }, + { + "source": "namespace", + "target": "Namespace" + }, + { + "source": "tableBucketARN", + "target": "TableBucketARN" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateTable", + "phase": "create", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::Table", + "mappings": [ + { + "source": "name", + "target": "TableName" + }, + { + "source": "namespace", + "target": "Namespace" + }, + { + "source": "tableBucketARN", + "target": "TableBucketARN" + } + ], + "operation": "DeleteTable", + "phase": "delete", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::TableBucket", + "mappings": [ + { + "source": "name", + "target": "TableBucketName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateTableBucket", + "phase": "create", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::TableBucket", + "mappings": [], + "operation": "DeleteTableBucket", + "phase": "delete", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::TableBucketPolicy", + "mappings": [ + { + "source": "resourcePolicy", + "target": "ResourcePolicy" + }, + { + "source": "tableBucketARN", + "target": "TableBucketARN" + } + ], + "operation": "PutTableBucketPolicy", + "phase": "create", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::TableBucketPolicy", + "mappings": [ + { + "source": "tableBucketARN", + "target": "TableBucketARN" + } + ], + "operation": "DeleteTableBucketPolicy", + "phase": "delete", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::TablePolicy", + "mappings": [ + { + "source": "resourcePolicy", + "target": "ResourcePolicy" + } + ], + "operation": "PutTablePolicy", + "phase": "create", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Tables::TablePolicy", + "mappings": [], + "operation": "DeleteTablePolicy", + "phase": "delete", + "service": "s3tables" + }, + { + "cfn_type": "AWS::S3Vectors::Index", + "mappings": [ + { + "source": "dataType", + "target": "DataType" + }, + { + "source": "dimension", + "target": "Dimension" + }, + { + "source": "distanceMetric", + "target": "DistanceMetric" + }, + { + "source": "indexName", + "target": "IndexName" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vectorBucketArn", + "target": "VectorBucketArn" + }, + { + "source": "vectorBucketName", + "target": "VectorBucketName" + } + ], + "operation": "CreateIndex", + "phase": "create", + "service": "s3vectors" + }, + { + "cfn_type": "AWS::S3Vectors::Index", + "mappings": [ + { + "source": "indexName", + "target": "IndexName" + }, + { + "source": "vectorBucketName", + "target": "VectorBucketName" + } + ], + "operation": "DeleteIndex", + "phase": "delete", + "service": "s3vectors" + }, + { + "cfn_type": "AWS::S3Vectors::VectorBucket", + "mappings": [ + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vectorBucketName", + "target": "VectorBucketName" + } + ], + "operation": "CreateVectorBucket", + "phase": "create", + "service": "s3vectors" + }, + { + "cfn_type": "AWS::S3Vectors::VectorBucket", + "mappings": [ + { + "source": "vectorBucketName", + "target": "VectorBucketName" + } + ], + "operation": "DeleteVectorBucket", + "phase": "delete", + "service": "s3vectors" + }, + { + "cfn_type": "AWS::S3Vectors::VectorBucketPolicy", + "mappings": [ + { + "source": "policy", + "target": "Policy" + }, + { + "source": "vectorBucketArn", + "target": "VectorBucketArn" + }, + { + "source": "vectorBucketName", + "target": "VectorBucketName" + } + ], + "operation": "PutVectorBucketPolicy", + "phase": "create", + "service": "s3vectors" + }, + { + "cfn_type": "AWS::S3Vectors::VectorBucketPolicy", + "mappings": [ + { + "source": "vectorBucketArn", + "target": "VectorBucketArn" + }, + { + "source": "vectorBucketName", + "target": "VectorBucketName" + } + ], + "operation": "DeleteVectorBucketPolicy", + "phase": "delete", + "service": "s3vectors" + }, + { + "cfn_type": "AWS::SCN::Dataset", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "instanceId", + "target": "InstanceId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "namespace", + "target": "Namespace" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDataLakeDataset", + "phase": "create", + "service": "supplychain" + }, + { + "cfn_type": "AWS::SCN::Dataset", + "mappings": [ + { + "source": "instanceId", + "target": "InstanceId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "namespace", + "target": "Namespace" + } + ], + "operation": "DeleteDataLakeDataset", + "phase": "delete", + "service": "supplychain" + }, + { + "cfn_type": "AWS::SCN::Namespace", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "instanceId", + "target": "InstanceId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateDataLakeNamespace", + "phase": "create", + "service": "supplychain" + }, + { + "cfn_type": "AWS::SCN::Namespace", + "mappings": [ + { + "source": "instanceId", + "target": "InstanceId" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "DeleteDataLakeNamespace", + "phase": "delete", + "service": "supplychain" + }, + { + "cfn_type": "AWS::SES::ConfigurationSetEventDestination", + "mappings": [ + { + "source": "ConfigurationSetName", + "target": "ConfigurationSetName" + } + ], + "operation": "CreateConfigurationSetEventDestination", + "phase": "create", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::ContactList", + "mappings": [ + { + "source": "ContactListName", + "target": "ContactListName" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateContactList", + "phase": "create", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::ContactList", + "mappings": [ + { + "source": "ContactListName", + "target": "ContactListName" + } + ], + "operation": "DeleteContactList", + "phase": "delete", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::CustomVerificationEmailTemplate", + "mappings": [ + { + "source": "FailureRedirectionURL", + "target": "FailureRedirectionURL" + }, + { + "source": "FromEmailAddress", + "target": "FromEmailAddress" + }, + { + "source": "SuccessRedirectionURL", + "target": "SuccessRedirectionURL" + }, + { + "source": "TemplateContent", + "target": "TemplateContent" + }, + { + "source": "TemplateName", + "target": "TemplateName" + }, + { + "source": "TemplateSubject", + "target": "TemplateSubject" + } + ], + "operation": "CreateCustomVerificationEmailTemplate", + "phase": "create", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::DedicatedIpPool", + "mappings": [ + { + "source": "PoolName", + "target": "PoolName" + }, + { + "source": "ScalingMode", + "target": "ScalingMode" + } + ], + "operation": "CreateDedicatedIpPool", + "phase": "create", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::DedicatedIpPool", + "mappings": [ + { + "source": "PoolName", + "target": "PoolName" + } + ], + "operation": "DeleteDedicatedIpPool", + "phase": "delete", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::EmailIdentity", + "mappings": [ + { + "source": "EmailIdentity", + "target": "EmailIdentity" + } + ], + "operation": "CreateEmailIdentity", + "phase": "create", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::EmailIdentity", + "mappings": [ + { + "source": "EmailIdentity", + "target": "EmailIdentity" + } + ], + "operation": "DeleteEmailIdentity", + "phase": "delete", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::MailManagerArchive", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ArchiveName", + "target": "ArchiveName" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + } + ], + "operation": "CreateArchive", + "phase": "create", + "service": "mailmanager" + }, + { + "cfn_type": "AWS::SES::MailManagerIngressPoint", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "IngressPointName", + "target": "IngressPointName" + }, + { + "source": "RuleSetId", + "target": "RuleSetId" + }, + { + "source": "TlsPolicy", + "target": "TlsPolicy" + }, + { + "source": "TrafficPolicyId", + "target": "TrafficPolicyId" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateIngressPoint", + "phase": "create", + "service": "mailmanager" + }, + { + "cfn_type": "AWS::SES::MailManagerRelay", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "RelayName", + "target": "RelayName" + }, + { + "source": "ServerName", + "target": "ServerName" + }, + { + "source": "ServerPort", + "target": "ServerPort" + } + ], + "operation": "CreateRelay", + "phase": "create", + "service": "mailmanager" + }, + { + "cfn_type": "AWS::SES::MailManagerTrafficPolicy", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DefaultAction", + "target": "DefaultAction" + }, + { + "source": "MaxMessageSizeBytes", + "target": "MaxMessageSizeBytes" + }, + { + "source": "TrafficPolicyName", + "target": "TrafficPolicyName" + } + ], + "operation": "CreateTrafficPolicy", + "phase": "create", + "service": "mailmanager" + }, + { + "cfn_type": "AWS::SES::MultiRegionEndpoint", + "mappings": [ + { + "source": "EndpointName", + "target": "EndpointName" + } + ], + "operation": "CreateMultiRegionEndpoint", + "phase": "create", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::MultiRegionEndpoint", + "mappings": [ + { + "source": "EndpointName", + "target": "EndpointName" + } + ], + "operation": "DeleteMultiRegionEndpoint", + "phase": "delete", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::ReceiptFilter", + "mappings": [], + "operation": "DeleteReceiptFilter", + "phase": "delete", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::ReceiptRule", + "mappings": [ + { + "source": "After", + "target": "After" + }, + { + "source": "RuleSetName", + "target": "RuleSetName" + } + ], + "operation": "CreateReceiptRule", + "phase": "create", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::ReceiptRule", + "mappings": [ + { + "source": "RuleSetName", + "target": "RuleSetName" + } + ], + "operation": "DeleteReceiptRule", + "phase": "delete", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::ReceiptRuleSet", + "mappings": [ + { + "source": "RuleSetName", + "target": "RuleSetName" + } + ], + "operation": "CreateReceiptRuleSet", + "phase": "create", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::ReceiptRuleSet", + "mappings": [ + { + "source": "RuleSetName", + "target": "RuleSetName" + } + ], + "operation": "DeleteReceiptRuleSet", + "phase": "delete", + "service": "ses" + }, + { + "cfn_type": "AWS::SES::Tenant", + "mappings": [ + { + "source": "TenantName", + "target": "TenantName" + } + ], + "operation": "CreateTenant", + "phase": "create", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SES::Tenant", + "mappings": [ + { + "source": "TenantName", + "target": "TenantName" + } + ], + "operation": "DeleteTenant", + "phase": "delete", + "service": "sesv2" + }, + { + "cfn_type": "AWS::SMSVOICE::ConfigurationSet", + "mappings": [ + { + "source": "ConfigurationSetName", + "target": "ConfigurationSetName" + } + ], + "operation": "CreateConfigurationSet", + "phase": "create", + "service": "pinpoint-sms-voice" + }, + { + "cfn_type": "AWS::SMSVOICE::OptOutList", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "OptOutListName", + "target": "OptOutListName" + } + ], + "operation": "CreateOptOutList", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::OptOutList", + "mappings": [ + { + "source": "OptOutListName", + "target": "OptOutListName" + } + ], + "operation": "DeleteOptOutList", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::PhoneNumber", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DeletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + }, + { + "source": "IsoCountryCode", + "target": "IsoCountryCode" + }, + { + "source": "NumberCapabilities", + "target": "NumberCapabilities" + }, + { + "source": "NumberType", + "target": "NumberType" + }, + { + "source": "OptOutListName", + "target": "OptOutListName" + } + ], + "operation": "RequestPhoneNumber", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::PhoneNumber", + "mappings": [], + "operation": "ReleasePhoneNumber", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::Pool", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DeletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + } + ], + "operation": "CreatePool", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::Pool", + "mappings": [], + "operation": "DeletePool", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::ProtectConfiguration", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DeletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + } + ], + "operation": "CreateProtectConfiguration", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::ProtectConfiguration", + "mappings": [], + "operation": "DeleteProtectConfiguration", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::Registration", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "RegistrationType", + "target": "RegistrationType" + } + ], + "operation": "CreateRegistration", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::Registration", + "mappings": [], + "operation": "DeleteRegistration", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::ResourcePolicy", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::ResourcePolicy", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::SenderId", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "DeletionProtectionEnabled", + "target": "DeletionProtectionEnabled" + }, + { + "source": "IsoCountryCode", + "target": "IsoCountryCode" + }, + { + "source": "SenderId", + "target": "SenderId" + } + ], + "operation": "RequestSenderId", + "phase": "create", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SMSVOICE::SenderId", + "mappings": [ + { + "source": "IsoCountryCode", + "target": "IsoCountryCode" + }, + { + "source": "SenderId", + "target": "SenderId" + } + ], + "operation": "ReleaseSenderId", + "phase": "delete", + "service": "pinpoint-sms-voice-v2" + }, + { + "cfn_type": "AWS::SNS::Subscription", + "mappings": [ + { + "source": "Endpoint", + "target": "Endpoint" + }, + { + "source": "Protocol", + "target": "Protocol" + }, + { + "source": "TopicArn", + "target": "TopicArn" + } + ], + "operation": "Subscribe", + "phase": "create", + "service": "sns" + }, + { + "cfn_type": "AWS::SNS::Topic", + "mappings": [ + { + "source": "DataProtectionPolicy", + "target": "DataProtectionPolicy" + }, + { + "source": "Name", + "target": "TopicName" + } + ], + "operation": "CreateTopic", + "phase": "create", + "service": "sns" + }, + { + "cfn_type": "AWS::SNS::Topic", + "mappings": [], + "operation": "DeleteTopic", + "phase": "delete", + "service": "sns" + }, + { + "cfn_type": "AWS::SQS::Queue", + "mappings": [ + { + "source": "QueueName", + "target": "QueueName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateQueue", + "phase": "create", + "service": "sqs" + }, + { + "cfn_type": "AWS::SQS::Queue", + "mappings": [], + "operation": "DeleteQueue", + "phase": "delete", + "service": "sqs" + }, + { + "cfn_type": "AWS::SSM::Association", + "mappings": [ + { + "source": "ApplyOnlyAtCronInterval", + "target": "ApplyOnlyAtCronInterval" + }, + { + "source": "AssociationDispatchAssumeRole", + "target": "AssociationDispatchAssumeRole" + }, + { + "source": "AssociationName", + "target": "AssociationName" + }, + { + "source": "AutomationTargetParameterName", + "target": "AutomationTargetParameterName" + }, + { + "source": "CalendarNames", + "target": "CalendarNames" + }, + { + "source": "ComplianceSeverity", + "target": "ComplianceSeverity" + }, + { + "source": "DocumentVersion", + "target": "DocumentVersion" + }, + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "MaxConcurrency", + "target": "MaxConcurrency" + }, + { + "source": "MaxErrors", + "target": "MaxErrors" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ScheduleExpression", + "target": "ScheduleExpression" + }, + { + "source": "ScheduleOffset", + "target": "ScheduleOffset" + }, + { + "source": "SyncCompliance", + "target": "SyncCompliance" + } + ], + "operation": "CreateAssociation", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::Association", + "mappings": [ + { + "source": "InstanceId", + "target": "InstanceId" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteAssociation", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::CloudConnector", + "mappings": [ + { + "source": "ConfigConnectorArn", + "target": "ConfigConnectorArn" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateCloudConnector", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::CloudConnector", + "mappings": [], + "operation": "DeleteCloudConnector", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::Document", + "mappings": [ + { + "source": "Content", + "target": "Content" + }, + { + "source": "DocumentFormat", + "target": "DocumentFormat" + }, + { + "source": "DocumentType", + "target": "DocumentType" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "TargetType", + "target": "TargetType" + }, + { + "source": "VersionName", + "target": "VersionName" + } + ], + "operation": "CreateDocument", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::Document", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "VersionName", + "target": "VersionName" + } + ], + "operation": "DeleteDocument", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::MaintenanceWindow", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AllowUnassociatedTargets", + "target": "AllowUnassociatedTargets" + }, + { + "source": "Cutoff", + "target": "Cutoff" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Duration", + "target": "Duration" + }, + { + "source": "EndDate", + "target": "EndDate" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Schedule", + "target": "Schedule" + }, + { + "source": "ScheduleOffset", + "target": "ScheduleOffset" + }, + { + "source": "ScheduleTimezone", + "target": "ScheduleTimezone" + }, + { + "source": "StartDate", + "target": "StartDate" + } + ], + "operation": "CreateMaintenanceWindow", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::MaintenanceWindow", + "mappings": [], + "operation": "DeleteMaintenanceWindow", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::MaintenanceWindowTarget", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OwnerInformation", + "target": "OwnerInformation" + }, + { + "source": "ResourceType", + "target": "ResourceType" + }, + { + "source": "WindowId", + "target": "WindowId" + } + ], + "operation": "RegisterTargetWithMaintenanceWindow", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::MaintenanceWindowTask", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CutoffBehavior", + "target": "CutoffBehavior" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "MaxConcurrency", + "target": "MaxConcurrency" + }, + { + "source": "MaxErrors", + "target": "MaxErrors" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Priority", + "target": "Priority" + }, + { + "source": "ServiceRoleArn", + "target": "ServiceRoleArn" + }, + { + "source": "TaskArn", + "target": "TaskArn" + }, + { + "source": "TaskType", + "target": "TaskType" + }, + { + "source": "WindowId", + "target": "WindowId" + } + ], + "operation": "RegisterTaskWithMaintenanceWindow", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::OpsItem", + "mappings": [ + { + "source": "Category", + "target": "Category" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Priority", + "target": "Priority" + }, + { + "source": "Severity", + "target": "Severity" + }, + { + "source": "Source", + "target": "Source" + }, + { + "source": "Title", + "target": "Title" + } + ], + "operation": "CreateOpsItem", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::OpsItem", + "mappings": [], + "operation": "DeleteOpsItem", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::Parameter", + "mappings": [ + { + "source": "AllowedPattern", + "target": "AllowedPattern" + }, + { + "source": "DataType", + "target": "DataType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Policies", + "target": "Policies" + }, + { + "source": "Tier", + "target": "Tier" + }, + { + "source": "Type", + "target": "Type" + }, + { + "source": "Value", + "target": "Value" + } + ], + "operation": "PutParameter", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::Parameter", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteParameter", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::PatchBaseline", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ApprovedPatches", + "target": "ApprovedPatches" + }, + { + "source": "ApprovedPatchesComplianceLevel", + "target": "ApprovedPatchesComplianceLevel" + }, + { + "source": "ApprovedPatchesEnableNonSecurity", + "target": "ApprovedPatchesEnableNonSecurity" + }, + { + "source": "AvailableSecurityUpdatesComplianceStatus", + "target": "AvailableSecurityUpdatesComplianceStatus" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "OperatingSystem", + "target": "OperatingSystem" + }, + { + "source": "RejectedPatches", + "target": "RejectedPatches" + }, + { + "source": "RejectedPatchesAction", + "target": "RejectedPatchesAction" + } + ], + "operation": "CreatePatchBaseline", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::PatchBaseline", + "mappings": [], + "operation": "DeletePatchBaseline", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::ResourceDataSync", + "mappings": [ + { + "source": "SyncName", + "target": "SyncName" + }, + { + "source": "SyncType", + "target": "SyncType" + } + ], + "operation": "CreateResourceDataSync", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::ResourceDataSync", + "mappings": [ + { + "source": "SyncName", + "target": "SyncName" + }, + { + "source": "SyncType", + "target": "SyncType" + } + ], + "operation": "DeleteResourceDataSync", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::ResourcePolicy", + "mappings": [ + { + "source": "Policy", + "target": "Policy" + }, + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSM::ResourcePolicy", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "ssm" + }, + { + "cfn_type": "AWS::SSMContacts::Contact", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "Alias", + "target": "Alias" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateContact", + "phase": "create", + "service": "ssm-contacts" + }, + { + "cfn_type": "AWS::SSMContacts::Contact", + "mappings": [], + "operation": "DeleteContact", + "phase": "delete", + "service": "ssm-contacts" + }, + { + "cfn_type": "AWS::SSMContacts::ContactChannel", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "ContactId", + "target": "ContactId" + }, + { + "source": "DeferActivation", + "target": "DeferActivation" + } + ], + "operation": "CreateContactChannel", + "phase": "create", + "service": "ssm-contacts" + }, + { + "cfn_type": "AWS::SSMContacts::ContactChannel", + "mappings": [], + "operation": "DeleteContactChannel", + "phase": "delete", + "service": "ssm-contacts" + }, + { + "cfn_type": "AWS::SSMContacts::Rotation", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "ContactIds", + "target": "ContactIds" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "TimeZoneId", + "target": "TimeZoneId" + } + ], + "operation": "CreateRotation", + "phase": "create", + "service": "ssm-contacts" + }, + { + "cfn_type": "AWS::SSMContacts::Rotation", + "mappings": [], + "operation": "DeleteRotation", + "phase": "delete", + "service": "ssm-contacts" + }, + { + "cfn_type": "AWS::SSMGuiConnect::Preferences", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [], + "operation": "DeleteConnectionRecordingPreferences", + "phase": "delete", + "service": "ssm-guiconnect" + }, + { + "cfn_type": "AWS::SSMIncidents::ReplicationSet", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateReplicationSet", + "phase": "create", + "service": "ssm-incidents" + }, + { + "cfn_type": "AWS::SSMIncidents::ReplicationSet", + "mappings": [], + "operation": "DeleteReplicationSet", + "phase": "delete", + "service": "ssm-incidents" + }, + { + "cfn_type": "AWS::SSMIncidents::ResponsePlan", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "engagements", + "target": "Engagements" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateResponsePlan", + "phase": "create", + "service": "ssm-incidents" + }, + { + "cfn_type": "AWS::SSMIncidents::ResponsePlan", + "mappings": [], + "operation": "DeleteResponsePlan", + "phase": "delete", + "service": "ssm-incidents" + }, + { + "cfn_type": "AWS::SSMQuickSetup::ConfigurationManager", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConfigurationManager", + "phase": "create", + "service": "ssm-quicksetup" + }, + { + "cfn_type": "AWS::SSMQuickSetup::ConfigurationManager", + "mappings": [], + "operation": "DeleteConfigurationManager", + "phase": "delete", + "service": "ssm-quicksetup" + }, + { + "cfn_type": "AWS::SSO::Application", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ApplicationProviderArn", + "target": "ApplicationProviderArn" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "InstanceArn", + "target": "InstanceArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Status", + "target": "Status" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::ApplicationAssignment", + "mappings": [ + { + "source": "ApplicationArn", + "target": "ApplicationArn" + }, + { + "source": "PrincipalId", + "target": "PrincipalId" + }, + { + "source": "PrincipalType", + "target": "PrincipalType" + } + ], + "operation": "CreateApplicationAssignment", + "phase": "create", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::ApplicationAssignment", + "mappings": [ + { + "source": "ApplicationArn", + "target": "ApplicationArn" + }, + { + "source": "PrincipalId", + "target": "PrincipalId" + }, + { + "source": "PrincipalType", + "target": "PrincipalType" + } + ], + "operation": "DeleteApplicationAssignment", + "phase": "delete", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::Assignment", + "mappings": [ + { + "source": "InstanceArn", + "target": "InstanceArn" + }, + { + "source": "PermissionSetArn", + "target": "PermissionSetArn" + }, + { + "source": "PrincipalId", + "target": "PrincipalId" + }, + { + "source": "PrincipalType", + "target": "PrincipalType" + }, + { + "source": "TargetId", + "target": "TargetId" + }, + { + "source": "TargetType", + "target": "TargetType" + } + ], + "operation": "CreateAccountAssignment", + "phase": "create", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::Assignment", + "mappings": [ + { + "source": "InstanceArn", + "target": "InstanceArn" + }, + { + "source": "PermissionSetArn", + "target": "PermissionSetArn" + }, + { + "source": "PrincipalId", + "target": "PrincipalId" + }, + { + "source": "PrincipalType", + "target": "PrincipalType" + }, + { + "source": "TargetId", + "target": "TargetId" + }, + { + "source": "TargetType", + "target": "TargetType" + } + ], + "operation": "DeleteAccountAssignment", + "phase": "delete", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::Instance", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateInstance", + "phase": "create", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::Instance", + "mappings": [], + "operation": "DeleteInstance", + "phase": "delete", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::InstanceAccessControlAttributeConfiguration", + "mappings": [ + { + "source": "InstanceArn", + "target": "InstanceArn" + } + ], + "operation": "CreateInstanceAccessControlAttributeConfiguration", + "phase": "create", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::InstanceAccessControlAttributeConfiguration", + "mappings": [ + { + "source": "InstanceArn", + "target": "InstanceArn" + } + ], + "operation": "DeleteInstanceAccessControlAttributeConfiguration", + "phase": "delete", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::PermissionSet", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "InstanceArn", + "target": "InstanceArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SessionDuration", + "target": "SessionDuration" + } + ], + "operation": "CreatePermissionSet", + "phase": "create", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SSO::PermissionSet", + "mappings": [ + { + "source": "InstanceArn", + "target": "InstanceArn" + } + ], + "operation": "DeletePermissionSet", + "phase": "delete", + "service": "sso-admin" + }, + { + "cfn_type": "AWS::SageMaker::Action", + "mappings": [ + { + "source": "ActionName", + "target": "ActionName" + }, + { + "source": "ActionType", + "target": "ActionType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Status", + "target": "Status" + } + ], + "operation": "CreateAction", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Action", + "mappings": [ + { + "source": "ActionName", + "target": "ActionName" + } + ], + "operation": "DeleteAction", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Algorithm", + "mappings": [ + { + "source": "AlgorithmDescription", + "target": "AlgorithmDescription" + }, + { + "source": "AlgorithmName", + "target": "AlgorithmName" + }, + { + "source": "CertifyForMarketplace", + "target": "CertifyForMarketplace" + } + ], + "operation": "CreateAlgorithm", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Algorithm", + "mappings": [ + { + "source": "AlgorithmName", + "target": "AlgorithmName" + } + ], + "operation": "DeleteAlgorithm", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::App", + "mappings": [ + { + "source": "AppName", + "target": "AppName" + }, + { + "source": "AppType", + "target": "AppType" + }, + { + "source": "DomainId", + "target": "DomainId" + }, + { + "source": "RecoveryMode", + "target": "RecoveryMode" + }, + { + "source": "UserProfileName", + "target": "UserProfileName" + } + ], + "operation": "CreateApp", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::App", + "mappings": [ + { + "source": "AppName", + "target": "AppName" + }, + { + "source": "AppType", + "target": "AppType" + }, + { + "source": "DomainId", + "target": "DomainId" + }, + { + "source": "UserProfileName", + "target": "UserProfileName" + } + ], + "operation": "DeleteApp", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::AppImageConfig", + "mappings": [ + { + "source": "AppImageConfigName", + "target": "AppImageConfigName" + } + ], + "operation": "CreateAppImageConfig", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::AppImageConfig", + "mappings": [ + { + "source": "AppImageConfigName", + "target": "AppImageConfigName" + } + ], + "operation": "DeleteAppImageConfig", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Artifact", + "mappings": [ + { + "source": "ArtifactName", + "target": "ArtifactName" + }, + { + "source": "ArtifactType", + "target": "ArtifactType" + } + ], + "operation": "CreateArtifact", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Artifact", + "mappings": [], + "operation": "DeleteArtifact", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Cluster", + "mappings": [ + { + "source": "ClusterName", + "target": "ClusterName" + }, + { + "source": "ClusterRole", + "target": "ClusterRole" + }, + { + "source": "NodeProvisioningMode", + "target": "NodeProvisioningMode" + }, + { + "source": "NodeRecovery", + "target": "NodeRecovery" + } + ], + "operation": "CreateCluster", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Cluster", + "mappings": [ + { + "source": "ClusterName", + "target": "ClusterName" + } + ], + "operation": "DeleteCluster", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Context", + "mappings": [ + { + "source": "ContextName", + "target": "ContextName" + }, + { + "source": "ContextType", + "target": "ContextType" + }, + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateContext", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Context", + "mappings": [ + { + "source": "ContextName", + "target": "ContextName" + } + ], + "operation": "DeleteContext", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::DataQualityJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateDataQualityJobDefinition", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::DataQualityJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + } + ], + "operation": "DeleteDataQualityJobDefinition", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Device", + "mappings": [ + { + "source": "DeviceFleetName", + "target": "DeviceFleetName" + } + ], + "operation": "RegisterDevices", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Device", + "mappings": [ + { + "source": "DeviceFleetName", + "target": "DeviceFleetName" + } + ], + "operation": "DeregisterDevices", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::DeviceFleet", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DeviceFleetName", + "target": "DeviceFleetName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateDeviceFleet", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::DeviceFleet", + "mappings": [ + { + "source": "DeviceFleetName", + "target": "DeviceFleetName" + } + ], + "operation": "DeleteDeviceFleet", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Domain", + "mappings": [ + { + "source": "AppNetworkAccessType", + "target": "AppNetworkAccessType" + }, + { + "source": "AppSecurityGroupManagement", + "target": "AppSecurityGroupManagement" + }, + { + "source": "AuthMode", + "target": "AuthMode" + }, + { + "source": "DomainName", + "target": "DomainName" + }, + { + "source": "HomeEfsFileSystemCreation", + "target": "HomeEfsFileSystemCreation" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "SubnetIds", + "target": "SubnetIds" + }, + { + "source": "TagPropagation", + "target": "TagPropagation" + }, + { + "source": "VpcId", + "target": "VpcId" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Domain", + "mappings": [], + "operation": "DeleteDomain", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Endpoint", + "mappings": [ + { + "source": "EndpointConfigName", + "target": "EndpointConfigName" + } + ], + "operation": "CreateEndpoint", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Endpoint", + "mappings": [], + "operation": "DeleteEndpoint", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Experiment", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "ExperimentName", + "target": "ExperimentName" + } + ], + "operation": "CreateExperiment", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Experiment", + "mappings": [ + { + "source": "ExperimentName", + "target": "ExperimentName" + } + ], + "operation": "DeleteExperiment", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::FeatureGroup", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EventTimeFeatureName", + "target": "EventTimeFeatureName" + }, + { + "source": "FeatureGroupName", + "target": "FeatureGroupName" + }, + { + "source": "RecordIdentifierFeatureName", + "target": "RecordIdentifierFeatureName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateFeatureGroup", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::FeatureGroup", + "mappings": [ + { + "source": "FeatureGroupName", + "target": "FeatureGroupName" + } + ], + "operation": "DeleteFeatureGroup", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Hub", + "mappings": [ + { + "source": "HubDescription", + "target": "HubDescription" + }, + { + "source": "HubDisplayName", + "target": "HubDisplayName" + }, + { + "source": "HubName", + "target": "HubName" + }, + { + "source": "HubSearchKeywords", + "target": "HubSearchKeywords" + } + ], + "operation": "CreateHub", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Hub", + "mappings": [ + { + "source": "HubName", + "target": "HubName" + } + ], + "operation": "DeleteHub", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::HumanTaskUi", + "mappings": [ + { + "source": "HumanTaskUiName", + "target": "HumanTaskUiName" + } + ], + "operation": "CreateHumanTaskUi", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::HumanTaskUi", + "mappings": [ + { + "source": "HumanTaskUiName", + "target": "HumanTaskUiName" + } + ], + "operation": "DeleteHumanTaskUi", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Image", + "mappings": [ + { + "source": "ImageName", + "target": "ImageName" + } + ], + "operation": "CreateImage", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Image", + "mappings": [ + { + "source": "ImageName", + "target": "ImageName" + } + ], + "operation": "DeleteImage", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ImageVersion", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Aliases", + "target": "Aliases" + }, + { + "source": "BaseImage", + "target": "BaseImage" + }, + { + "source": "Horovod", + "target": "Horovod" + }, + { + "source": "ImageName", + "target": "ImageName" + }, + { + "source": "JobType", + "target": "JobType" + }, + { + "source": "MLFramework", + "target": "MLFramework" + }, + { + "source": "Processor", + "target": "Processor" + }, + { + "source": "ProgrammingLang", + "target": "ProgrammingLang" + }, + { + "source": "ReleaseNotes", + "target": "ReleaseNotes" + }, + { + "source": "VendorGuidance", + "target": "VendorGuidance" + } + ], + "operation": "CreateImageVersion", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ImageVersion", + "mappings": [ + { + "source": "Alias", + "target": "Alias" + }, + { + "source": "ImageName", + "target": "ImageName" + } + ], + "operation": "DeleteImageVersion", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::InferenceComponent", + "mappings": [ + { + "source": "EndpointName", + "target": "EndpointName" + }, + { + "source": "InferenceComponentName", + "target": "InferenceComponentName" + }, + { + "source": "VariantName", + "target": "VariantName" + } + ], + "operation": "CreateInferenceComponent", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::InferenceComponent", + "mappings": [ + { + "source": "InferenceComponentName", + "target": "InferenceComponentName" + } + ], + "operation": "DeleteInferenceComponent", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::InferenceExperiment", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "EndpointName", + "target": "EndpointName" + }, + { + "source": "KmsKey", + "target": "KmsKey" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateInferenceExperiment", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::InferenceExperiment", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteInferenceExperiment", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::MlflowApp", + "mappings": [ + { + "source": "ArtifactStoreUri", + "target": "ArtifactStoreUri" + }, + { + "source": "ModelRegistrationMode", + "target": "ModelRegistrationMode" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "WeeklyMaintenanceWindowStart", + "target": "WeeklyMaintenanceWindowStart" + } + ], + "operation": "CreateMlflowApp", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::MlflowApp", + "mappings": [], + "operation": "DeleteMlflowApp", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::MlflowTrackingServer", + "mappings": [ + { + "source": "ArtifactStoreUri", + "target": "ArtifactStoreUri" + }, + { + "source": "AutomaticModelRegistration", + "target": "AutomaticModelRegistration" + }, + { + "source": "MlflowVersion", + "target": "MlflowVersion" + }, + { + "source": "RoleArn", + "target": "RoleArn" + }, + { + "source": "TrackingServerName", + "target": "TrackingServerName" + }, + { + "source": "TrackingServerSize", + "target": "TrackingServerSize" + }, + { + "source": "WeeklyMaintenanceWindowStart", + "target": "WeeklyMaintenanceWindowStart" + } + ], + "operation": "CreateMlflowTrackingServer", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::MlflowTrackingServer", + "mappings": [ + { + "source": "TrackingServerName", + "target": "TrackingServerName" + } + ], + "operation": "DeleteMlflowTrackingServer", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Model", + "mappings": [ + { + "source": "EnableNetworkIsolation", + "target": "EnableNetworkIsolation" + }, + { + "source": "ExecutionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "ModelName", + "target": "ModelName" + } + ], + "operation": "CreateModel", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Model", + "mappings": [ + { + "source": "ModelName", + "target": "ModelName" + } + ], + "operation": "DeleteModel", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelBiasJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateModelBiasJobDefinition", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelBiasJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + } + ], + "operation": "DeleteModelBiasJobDefinition", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelCard", + "mappings": [ + { + "source": "ModelCardName", + "target": "ModelCardName" + }, + { + "source": "ModelCardStatus", + "target": "ModelCardStatus" + } + ], + "operation": "CreateModelCard", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelCard", + "mappings": [ + { + "source": "ModelCardName", + "target": "ModelCardName" + } + ], + "operation": "DeleteModelCard", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelExplainabilityJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateModelExplainabilityJobDefinition", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelExplainabilityJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + } + ], + "operation": "DeleteModelExplainabilityJobDefinition", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelPackage", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "CertifyForMarketplace", + "target": "CertifyForMarketplace" + }, + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "ModelApprovalStatus", + "target": "ModelApprovalStatus" + }, + { + "source": "ModelPackageDescription", + "target": "ModelPackageDescription" + }, + { + "source": "ModelPackageGroupName", + "target": "ModelPackageGroupName" + }, + { + "source": "ModelPackageName", + "target": "ModelPackageName" + }, + { + "source": "SamplePayloadUrl", + "target": "SamplePayloadUrl" + }, + { + "source": "SkipModelValidation", + "target": "SkipModelValidation" + }, + { + "source": "SourceUri", + "target": "SourceUri" + }, + { + "source": "Task", + "target": "Task" + } + ], + "operation": "CreateModelPackage", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelPackage", + "mappings": [ + { + "source": "ModelPackageName", + "target": "ModelPackageName" + } + ], + "operation": "DeleteModelPackage", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelPackageGroup", + "mappings": [ + { + "source": "ModelPackageGroupDescription", + "target": "ModelPackageGroupDescription" + }, + { + "source": "ModelPackageGroupName", + "target": "ModelPackageGroupName" + } + ], + "operation": "CreateModelPackageGroup", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelPackageGroup", + "mappings": [ + { + "source": "ModelPackageGroupName", + "target": "ModelPackageGroupName" + } + ], + "operation": "DeleteModelPackageGroup", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelQualityJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateModelQualityJobDefinition", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ModelQualityJobDefinition", + "mappings": [ + { + "source": "JobDefinitionName", + "target": "JobDefinitionName" + } + ], + "operation": "DeleteModelQualityJobDefinition", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::MonitoringSchedule", + "mappings": [ + { + "source": "MonitoringScheduleName", + "target": "MonitoringScheduleName" + } + ], + "operation": "CreateMonitoringSchedule", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::MonitoringSchedule", + "mappings": [ + { + "source": "MonitoringScheduleName", + "target": "MonitoringScheduleName" + } + ], + "operation": "DeleteMonitoringSchedule", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::PartnerApp", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AuthType", + "target": "AuthType" + }, + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "EnableAutoMinorVersionUpgrade", + "target": "EnableAutoMinorVersionUpgrade" + }, + { + "source": "EnableIamSessionBasedIdentity", + "target": "EnableIamSessionBasedIdentity" + }, + { + "source": "ExecutionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tier", + "target": "Tier" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreatePartnerApp", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::PartnerApp", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClientToken", + "target": "ClientToken" + } + ], + "operation": "DeletePartnerApp", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Pipeline", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "PipelineDescription", + "target": "PipelineDescription" + }, + { + "source": "PipelineDisplayName", + "target": "PipelineDisplayName" + }, + { + "source": "PipelineName", + "target": "PipelineName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreatePipeline", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Pipeline", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "PipelineName", + "target": "PipelineName" + } + ], + "operation": "DeletePipeline", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ProcessingJob", + "mappings": [ + { + "source": "ProcessingJobName", + "target": "ProcessingJobName" + }, + { + "source": "RoleArn", + "target": "RoleArn" + } + ], + "operation": "CreateProcessingJob", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::ProcessingJob", + "mappings": [ + { + "source": "ProcessingJobName", + "target": "ProcessingJobName" + } + ], + "operation": "DeleteProcessingJob", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Project", + "mappings": [ + { + "source": "ProjectDescription", + "target": "ProjectDescription" + }, + { + "source": "ProjectName", + "target": "ProjectName" + } + ], + "operation": "CreateProject", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Project", + "mappings": [ + { + "source": "ProjectName", + "target": "ProjectName" + } + ], + "operation": "DeleteProject", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Space", + "mappings": [ + { + "source": "DomainId", + "target": "DomainId" + }, + { + "source": "SpaceDisplayName", + "target": "SpaceDisplayName" + }, + { + "source": "SpaceName", + "target": "SpaceName" + } + ], + "operation": "CreateSpace", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Space", + "mappings": [ + { + "source": "DomainId", + "target": "DomainId" + }, + { + "source": "SpaceName", + "target": "SpaceName" + } + ], + "operation": "DeleteSpace", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::StudioLifecycleConfig", + "mappings": [ + { + "source": "StudioLifecycleConfigAppType", + "target": "StudioLifecycleConfigAppType" + }, + { + "source": "StudioLifecycleConfigContent", + "target": "StudioLifecycleConfigContent" + }, + { + "source": "StudioLifecycleConfigName", + "target": "StudioLifecycleConfigName" + } + ], + "operation": "CreateStudioLifecycleConfig", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::StudioLifecycleConfig", + "mappings": [ + { + "source": "StudioLifecycleConfigName", + "target": "StudioLifecycleConfigName" + } + ], + "operation": "DeleteStudioLifecycleConfig", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::TrialComponent", + "mappings": [ + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "TrialComponentName", + "target": "TrialComponentName" + } + ], + "operation": "CreateTrialComponent", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::TrialComponent", + "mappings": [ + { + "source": "TrialComponentName", + "target": "TrialComponentName" + } + ], + "operation": "DeleteTrialComponent", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::UserProfile", + "mappings": [ + { + "source": "DomainId", + "target": "DomainId" + }, + { + "source": "SingleSignOnUserIdentifier", + "target": "SingleSignOnUserIdentifier" + }, + { + "source": "SingleSignOnUserValue", + "target": "SingleSignOnUserValue" + }, + { + "source": "UserProfileName", + "target": "UserProfileName" + } + ], + "operation": "CreateUserProfile", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::UserProfile", + "mappings": [ + { + "source": "DomainId", + "target": "DomainId" + }, + { + "source": "UserProfileName", + "target": "UserProfileName" + } + ], + "operation": "DeleteUserProfile", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Workforce", + "mappings": [ + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "WorkforceName", + "target": "WorkforceName" + } + ], + "operation": "CreateWorkforce", + "phase": "create", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::SageMaker::Workforce", + "mappings": [ + { + "source": "WorkforceName", + "target": "WorkforceName" + } + ], + "operation": "DeleteWorkforce", + "phase": "delete", + "service": "sagemaker" + }, + { + "cfn_type": "AWS::Scheduler::Schedule", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ScheduleExpression", + "target": "ScheduleExpression" + }, + { + "source": "ScheduleExpressionTimezone", + "target": "ScheduleExpressionTimezone" + }, + { + "source": "State", + "target": "State" + } + ], + "operation": "CreateSchedule", + "phase": "create", + "service": "scheduler" + }, + { + "cfn_type": "AWS::Scheduler::Schedule", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteSchedule", + "phase": "delete", + "service": "scheduler" + }, + { + "cfn_type": "AWS::Scheduler::ScheduleGroup", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateScheduleGroup", + "phase": "create", + "service": "scheduler" + }, + { + "cfn_type": "AWS::Scheduler::ScheduleGroup", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteScheduleGroup", + "phase": "delete", + "service": "scheduler" + }, + { + "cfn_type": "AWS::SecretsManager::ResourcePolicy", + "mappings": [ + { + "source": "BlockPublicPolicy", + "target": "BlockPublicPolicy" + }, + { + "source": "ResourcePolicy", + "target": "ResourcePolicy" + }, + { + "source": "SecretId", + "target": "SecretId" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "secretsmanager" + }, + { + "cfn_type": "AWS::SecretsManager::ResourcePolicy", + "mappings": [ + { + "source": "SecretId", + "target": "SecretId" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "secretsmanager" + }, + { + "cfn_type": "AWS::SecretsManager::Secret", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "SecretString", + "target": "SecretString" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateSecret", + "phase": "create", + "service": "secretsmanager" + }, + { + "cfn_type": "AWS::SecretsManager::Secret", + "mappings": [], + "operation": "DeleteSecret", + "phase": "delete", + "service": "secretsmanager" + }, + { + "cfn_type": "AWS::SecurityAgent::AgentSpace", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetDomainIds", + "target": "TargetDomainIds" + } + ], + "operation": "CreateAgentSpace", + "phase": "create", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::AgentSpace", + "mappings": [], + "operation": "DeleteAgentSpace", + "phase": "delete", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::Application", + "mappings": [ + { + "source": "defaultKmsKeyId", + "target": "DefaultKmsKeyId" + }, + { + "source": "roleArn", + "target": "RoleArn" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::Artifact", + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + }, + { + "source": "artifactType", + "target": "ArtifactType" + }, + { + "source": "fileName", + "target": "FileName" + } + ], + "operation": "AddArtifact", + "phase": "create", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::Artifact", + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + } + ], + "operation": "DeleteArtifact", + "phase": "delete", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::Pentest", + "mappings": [ + { + "source": "agentSpaceId", + "target": "AgentSpaceId" + }, + { + "source": "codeRemediationStrategy", + "target": "CodeRemediationStrategy" + }, + { + "source": "disableManagedSkills", + "target": "DisableManagedSkills" + }, + { + "source": "excludeRiskTypes", + "target": "ExcludeRiskTypes" + }, + { + "source": "serviceRole", + "target": "ServiceRole" + }, + { + "source": "title", + "target": "Title" + } + ], + "operation": "CreatePentest", + "phase": "create", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::SecurityRequirementPack", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "kmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "status", + "target": "Status" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateSecurityRequirementPack", + "phase": "create", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::SecurityRequirementPack", + "mappings": [], + "operation": "DeleteSecurityRequirementPack", + "phase": "delete", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::TargetDomain", + "mappings": [ + { + "source": "tags", + "target": "Tags" + }, + { + "source": "targetDomainName", + "target": "TargetDomainName" + }, + { + "source": "verificationMethod", + "target": "VerificationMethod" + } + ], + "operation": "CreateTargetDomain", + "phase": "create", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityAgent::TargetDomain", + "mappings": [], + "operation": "DeleteTargetDomain", + "phase": "delete", + "service": "securityagent" + }, + { + "cfn_type": "AWS::SecurityHub::AggregatorV2", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "LinkedRegions", + "target": "LinkedRegions" + }, + { + "source": "RegionLinkingMode", + "target": "RegionLinkingMode" + } + ], + "operation": "CreateAggregatorV2", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::AggregatorV2", + "mappings": [], + "operation": "DeleteAggregatorV2", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::AutomationRule", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "IsTerminal", + "target": "IsTerminal" + }, + { + "source": "RuleName", + "target": "RuleName" + }, + { + "source": "RuleOrder", + "target": "RuleOrder" + }, + { + "source": "RuleStatus", + "target": "RuleStatus" + } + ], + "operation": "CreateAutomationRule", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::AutomationRuleV2", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "RuleName", + "target": "RuleName" + }, + { + "source": "RuleOrder", + "target": "RuleOrder" + }, + { + "source": "RuleStatus", + "target": "RuleStatus" + } + ], + "operation": "CreateAutomationRuleV2", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::AutomationRuleV2", + "mappings": [], + "operation": "DeleteAutomationRuleV2", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::ConfigurationPolicy", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConfigurationPolicy", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::ConfigurationPolicy", + "mappings": [], + "operation": "DeleteConfigurationPolicy", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::Connector", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConnector", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::Connector", + "mappings": [], + "operation": "DeleteConnector", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::ConnectorV2", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateConnectorV2", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::ConnectorV2", + "mappings": [], + "operation": "DeleteConnectorV2", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::FindingAggregator", + "mappings": [ + { + "source": "RegionLinkingMode", + "target": "RegionLinkingMode" + }, + { + "source": "Regions", + "target": "Regions" + } + ], + "operation": "CreateFindingAggregator", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::FindingAggregator", + "mappings": [], + "operation": "DeleteFindingAggregator", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::Hub", + "mappings": [ + { + "source": "ControlFindingGenerator", + "target": "ControlFindingGenerator" + }, + { + "source": "EnableDefaultStandards", + "target": "EnableDefaultStandards" + } + ], + "operation": "EnableSecurityHub", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::Insight", + "mappings": [ + { + "source": "GroupByAttribute", + "target": "GroupByAttribute" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateInsight", + "phase": "create", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityHub::Insight", + "mappings": [], + "operation": "DeleteInsight", + "phase": "delete", + "service": "securityhub" + }, + { + "cfn_type": "AWS::SecurityLake::AwsLogSource", + "mappings": [], + "operation": "DeleteAwsLogSource", + "phase": "delete", + "service": "securitylake" + }, + { + "cfn_type": "AWS::SecurityLake::DataLake", + "mappings": [ + { + "source": "metaStoreManagerRoleArn", + "target": "MetaStoreManagerRoleArn" + } + ], + "operation": "CreateDataLake", + "phase": "create", + "service": "securitylake" + }, + { + "cfn_type": "AWS::SecurityLake::DataLake", + "mappings": [], + "operation": "DeleteDataLake", + "phase": "delete", + "service": "securitylake" + }, + { + "cfn_type": "AWS::SecurityLake::Subscriber", + "mappings": [ + { + "source": "accessTypes", + "target": "AccessTypes" + }, + { + "source": "subscriberDescription", + "target": "SubscriberDescription" + }, + { + "source": "subscriberName", + "target": "SubscriberName" + } + ], + "operation": "CreateSubscriber", + "phase": "create", + "service": "securitylake" + }, + { + "cfn_type": "AWS::SecurityLake::Subscriber", + "mappings": [], + "operation": "DeleteSubscriber", + "phase": "delete", + "service": "securitylake" + }, + { + "cfn_type": "AWS::SecurityLake::SubscriberNotification", + "mappings": [], + "operation": "DeleteSubscriberNotification", + "phase": "delete", + "service": "securitylake" + }, + { + "cfn_type": "AWS::ServerlessRepo::Application", + "mappings": [ + { + "source": "Author", + "target": "Author" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "HomePageUrl", + "target": "HomePageUrl" + }, + { + "source": "Labels", + "target": "Labels" + }, + { + "source": "LicenseBody", + "target": "LicenseBody" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ReadmeBody", + "target": "ReadmeBody" + }, + { + "source": "SemanticVersion", + "target": "SemanticVersion" + }, + { + "source": "SourceCodeUrl", + "target": "SourceCodeUrl" + }, + { + "source": "SpdxLicenseId", + "target": "SpdxLicenseId" + }, + { + "source": "TemplateBody", + "target": "TemplateBody" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "serverlessrepo" + }, + { + "cfn_type": "AWS::ServerlessRepo::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "serverlessrepo" + }, + { + "cfn_type": "AWS::ServiceCatalog::CloudFormationProduct", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Distributor", + "target": "Distributor" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Owner", + "target": "Owner" + }, + { + "source": "ProductType", + "target": "ProductType" + }, + { + "source": "SupportDescription", + "target": "SupportDescription" + }, + { + "source": "SupportEmail", + "target": "SupportEmail" + }, + { + "source": "SupportUrl", + "target": "SupportUrl" + } + ], + "operation": "CreateProduct", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::CloudFormationProvisionedProduct", + "ignored_inputs": [ + "ProvisionToken" + ], + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "NotificationArns", + "target": "NotificationArns" + }, + { + "source": "PathId", + "target": "PathId" + }, + { + "source": "PathName", + "target": "PathName" + }, + { + "source": "ProductId", + "target": "ProductId" + }, + { + "source": "ProductName", + "target": "ProductName" + }, + { + "source": "ProvisionedProductName", + "target": "ProvisionedProductName" + }, + { + "source": "ProvisioningArtifactId", + "target": "ProvisioningArtifactId" + }, + { + "source": "ProvisioningArtifactName", + "target": "ProvisioningArtifactName" + } + ], + "operation": "ProvisionProduct", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::CloudFormationProvisionedProduct", + "ignored_inputs": [ + "TerminateToken" + ], + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "ProvisionedProductName", + "target": "ProvisionedProductName" + } + ], + "operation": "TerminateProvisionedProduct", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::Portfolio", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DisplayName", + "target": "DisplayName" + }, + { + "source": "ProviderName", + "target": "ProviderName" + } + ], + "operation": "CreatePortfolio", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::Portfolio", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + } + ], + "operation": "DeletePortfolio", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::PortfolioPrincipalAssociation", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "PortfolioId", + "target": "PortfolioId" + }, + { + "source": "PrincipalARN", + "target": "PrincipalARN" + }, + { + "source": "PrincipalType", + "target": "PrincipalType" + } + ], + "operation": "AssociatePrincipalWithPortfolio", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::PortfolioPrincipalAssociation", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "PortfolioId", + "target": "PortfolioId" + }, + { + "source": "PrincipalARN", + "target": "PrincipalARN" + }, + { + "source": "PrincipalType", + "target": "PrincipalType" + } + ], + "operation": "DisassociatePrincipalFromPortfolio", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::PortfolioProductAssociation", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "PortfolioId", + "target": "PortfolioId" + }, + { + "source": "ProductId", + "target": "ProductId" + }, + { + "source": "SourcePortfolioId", + "target": "SourcePortfolioId" + } + ], + "operation": "AssociateProductWithPortfolio", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::PortfolioProductAssociation", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "PortfolioId", + "target": "PortfolioId" + }, + { + "source": "ProductId", + "target": "ProductId" + } + ], + "operation": "DisassociateProductFromPortfolio", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::PortfolioShare", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "AccountId", + "target": "AccountId" + }, + { + "source": "PortfolioId", + "target": "PortfolioId" + }, + { + "source": "ShareTagOptions", + "target": "ShareTagOptions" + } + ], + "operation": "CreatePortfolioShare", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::PortfolioShare", + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "AccountId", + "target": "AccountId" + }, + { + "source": "PortfolioId", + "target": "PortfolioId" + } + ], + "operation": "DeletePortfolioShare", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::ServiceAction", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + }, + { + "source": "DefinitionType", + "target": "DefinitionType" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateServiceAction", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::ServiceAction", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "AcceptLanguage", + "target": "AcceptLanguage" + } + ], + "operation": "DeleteServiceAction", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::ServiceActionAssociation", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "ProductId", + "target": "ProductId" + }, + { + "source": "ProvisioningArtifactId", + "target": "ProvisioningArtifactId" + }, + { + "source": "ServiceActionId", + "target": "ServiceActionId" + } + ], + "operation": "AssociateServiceActionWithProvisioningArtifact", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::ServiceActionAssociation", + "ignored_inputs": [ + "IdempotencyToken" + ], + "mappings": [ + { + "source": "ProductId", + "target": "ProductId" + }, + { + "source": "ProvisioningArtifactId", + "target": "ProvisioningArtifactId" + }, + { + "source": "ServiceActionId", + "target": "ServiceActionId" + } + ], + "operation": "DisassociateServiceActionFromProvisioningArtifact", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::TagOption", + "mappings": [ + { + "source": "Key", + "target": "Key" + }, + { + "source": "Value", + "target": "Value" + } + ], + "operation": "CreateTagOption", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::TagOption", + "mappings": [], + "operation": "DeleteTagOption", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::TagOptionAssociation", + "mappings": [ + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "TagOptionId", + "target": "TagOptionId" + } + ], + "operation": "AssociateTagOptionWithResource", + "phase": "create", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalog::TagOptionAssociation", + "mappings": [ + { + "source": "ResourceId", + "target": "ResourceId" + }, + { + "source": "TagOptionId", + "target": "TagOptionId" + } + ], + "operation": "DisassociateTagOptionFromResource", + "phase": "delete", + "service": "servicecatalog" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::Application", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateApplication", + "phase": "create", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::Application", + "mappings": [], + "operation": "DeleteApplication", + "phase": "delete", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::AttributeGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "attributes", + "target": "Attributes" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateAttributeGroup", + "phase": "create", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::AttributeGroup", + "mappings": [], + "operation": "DeleteAttributeGroup", + "phase": "delete", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::AttributeGroupAssociation", + "mappings": [ + { + "source": "application", + "target": "Application" + }, + { + "source": "attributeGroup", + "target": "AttributeGroup" + } + ], + "operation": "AssociateAttributeGroup", + "phase": "create", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::AttributeGroupAssociation", + "mappings": [ + { + "source": "application", + "target": "Application" + }, + { + "source": "attributeGroup", + "target": "AttributeGroup" + } + ], + "operation": "DisassociateAttributeGroup", + "phase": "delete", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::ResourceAssociation", + "mappings": [ + { + "source": "application", + "target": "Application" + }, + { + "source": "resource", + "target": "Resource" + }, + { + "source": "resourceType", + "target": "ResourceType" + } + ], + "operation": "AssociateResource", + "phase": "create", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceCatalogAppRegistry::ResourceAssociation", + "mappings": [ + { + "source": "application", + "target": "Application" + }, + { + "source": "resource", + "target": "Resource" + }, + { + "source": "resourceType", + "target": "ResourceType" + } + ], + "operation": "DisassociateResource", + "phase": "delete", + "service": "servicecatalog-appregistry" + }, + { + "cfn_type": "AWS::ServiceDiscovery::PrivateDnsNamespace", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Vpc", + "target": "Vpc" + } + ], + "operation": "CreatePrivateDnsNamespace", + "phase": "create", + "service": "servicediscovery" + }, + { + "cfn_type": "AWS::ServiceDiscovery::PublicDnsNamespace", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreatePublicDnsNamespace", + "phase": "create", + "service": "servicediscovery" + }, + { + "cfn_type": "AWS::ServiceDiscovery::Service", + "ignored_inputs": [ + "CreatorRequestId" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "NamespaceId", + "target": "NamespaceId" + }, + { + "source": "Type", + "target": "Type" + } + ], + "operation": "CreateService", + "phase": "create", + "service": "servicediscovery" + }, + { + "cfn_type": "AWS::ServiceDiscovery::Service", + "mappings": [], + "operation": "DeleteService", + "phase": "delete", + "service": "servicediscovery" + }, + { + "cfn_type": "AWS::Shield::Protection", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "CreateProtection", + "phase": "create", + "service": "shield" + }, + { + "cfn_type": "AWS::Shield::Protection", + "mappings": [], + "operation": "DeleteProtection", + "phase": "delete", + "service": "shield" + }, + { + "cfn_type": "AWS::Shield::ProtectionGroup", + "mappings": [ + { + "source": "Aggregation", + "target": "Aggregation" + }, + { + "source": "Members", + "target": "Members" + }, + { + "source": "Pattern", + "target": "Pattern" + }, + { + "source": "ProtectionGroupId", + "target": "ProtectionGroupId" + }, + { + "source": "ResourceType", + "target": "ResourceType" + } + ], + "operation": "CreateProtectionGroup", + "phase": "create", + "service": "shield" + }, + { + "cfn_type": "AWS::Shield::ProtectionGroup", + "mappings": [ + { + "source": "ProtectionGroupId", + "target": "ProtectionGroupId" + } + ], + "operation": "DeleteProtectionGroup", + "phase": "delete", + "service": "shield" + }, + { + "cfn_type": "AWS::Signer::ProfilePermission", + "mappings": [ + { + "source": "action", + "target": "Action" + }, + { + "source": "principal", + "target": "Principal" + }, + { + "source": "profileName", + "target": "ProfileName" + }, + { + "source": "profileVersion", + "target": "ProfileVersion" + }, + { + "source": "statementId", + "target": "StatementId" + } + ], + "operation": "AddProfilePermission", + "phase": "create", + "service": "signer" + }, + { + "cfn_type": "AWS::Signer::ProfilePermission", + "mappings": [ + { + "source": "profileName", + "target": "ProfileName" + }, + { + "source": "statementId", + "target": "StatementId" + } + ], + "operation": "RemoveProfilePermission", + "phase": "delete", + "service": "signer" + }, + { + "cfn_type": "AWS::Signer::SigningProfile", + "mappings": [ + { + "source": "platformId", + "target": "PlatformId" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "PutSigningProfile", + "phase": "create", + "service": "signer" + }, + { + "cfn_type": "AWS::Signer::SigningProfile", + "mappings": [], + "operation": "CancelSigningProfile", + "phase": "delete", + "service": "signer" + }, + { + "cfn_type": "AWS::StepFunctions::Activity", + "mappings": [ + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateActivity", + "phase": "create", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::Activity", + "mappings": [], + "operation": "DeleteActivity", + "phase": "delete", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::StateMachine", + "mappings": [ + { + "source": "name", + "target": "StateMachineName" + }, + { + "source": "roleArn", + "target": "RoleArn" + } + ], + "operation": "CreateStateMachine", + "phase": "create", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::StateMachine", + "mappings": [], + "operation": "DeleteStateMachine", + "phase": "delete", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::StateMachineAlias", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateStateMachineAlias", + "phase": "create", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::StateMachineAlias", + "mappings": [], + "operation": "DeleteStateMachineAlias", + "phase": "delete", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::StateMachineVersion", + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "stateMachineArn", + "target": "StateMachineArn" + } + ], + "operation": "PublishStateMachineVersion", + "phase": "create", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StepFunctions::StateMachineVersion", + "mappings": [], + "operation": "DeleteStateMachineVersion", + "phase": "delete", + "service": "stepfunctions" + }, + { + "cfn_type": "AWS::StorageGateway::TapePool", + "mappings": [ + { + "source": "PoolName", + "target": "PoolName" + }, + { + "source": "RetentionLockTimeInDays", + "target": "RetentionLockTimeInDays" + }, + { + "source": "RetentionLockType", + "target": "RetentionLockType" + }, + { + "source": "StorageClass", + "target": "StorageClass" + } + ], + "operation": "CreateTapePool", + "phase": "create", + "service": "storagegateway" + }, + { + "cfn_type": "AWS::StorageGateway::TapePool", + "mappings": [], + "operation": "DeleteTapePool", + "phase": "delete", + "service": "storagegateway" + }, + { + "cfn_type": "AWS::SupportApp::AccountAlias", + "mappings": [ + { + "source": "accountAlias", + "target": "AccountAlias" + } + ], + "operation": "PutAccountAlias", + "phase": "create", + "service": "support-app" + }, + { + "cfn_type": "AWS::SupportApp::AccountAlias", + "mappings": [], + "operation": "DeleteAccountAlias", + "phase": "delete", + "service": "support-app" + }, + { + "cfn_type": "AWS::SupportApp::SlackChannelConfiguration", + "mappings": [ + { + "source": "channelId", + "target": "ChannelId" + }, + { + "source": "channelName", + "target": "ChannelName" + }, + { + "source": "channelRoleArn", + "target": "ChannelRoleArn" + }, + { + "source": "notifyOnAddCorrespondenceToCase", + "target": "NotifyOnAddCorrespondenceToCase" + }, + { + "source": "notifyOnCaseSeverity", + "target": "NotifyOnCaseSeverity" + }, + { + "source": "notifyOnCreateOrReopenCase", + "target": "NotifyOnCreateOrReopenCase" + }, + { + "source": "notifyOnResolveCase", + "target": "NotifyOnResolveCase" + }, + { + "source": "teamId", + "target": "TeamId" + } + ], + "operation": "CreateSlackChannelConfiguration", + "phase": "create", + "service": "support-app" + }, + { + "cfn_type": "AWS::SupportApp::SlackChannelConfiguration", + "mappings": [ + { + "source": "channelId", + "target": "ChannelId" + }, + { + "source": "teamId", + "target": "TeamId" + } + ], + "operation": "DeleteSlackChannelConfiguration", + "phase": "delete", + "service": "support-app" + }, + { + "cfn_type": "AWS::SupportApp::SlackWorkspaceConfiguration", + "mappings": [ + { + "source": "teamId", + "target": "TeamId" + } + ], + "operation": "DeleteSlackWorkspaceConfiguration", + "phase": "delete", + "service": "support-app" + }, + { + "cfn_type": "AWS::Synthetics::Canary", + "mappings": [ + { + "source": "ArtifactS3Location", + "target": "ArtifactS3Location" + }, + { + "source": "ExecutionRoleArn", + "target": "ExecutionRoleArn" + }, + { + "source": "KmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "ProvisionedResourceCleanup", + "target": "ProvisionedResourceCleanup" + }, + { + "source": "ResourcesToReplicateTags", + "target": "ResourcesToReplicateTags" + }, + { + "source": "RuntimeVersion", + "target": "RuntimeVersion" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateCanary", + "phase": "create", + "service": "synthetics" + }, + { + "cfn_type": "AWS::Synthetics::Canary", + "mappings": [ + { + "source": "Name", + "target": "Name" + } + ], + "operation": "DeleteCanary", + "phase": "delete", + "service": "synthetics" + }, + { + "cfn_type": "AWS::Synthetics::Group", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateGroup", + "phase": "create", + "service": "synthetics" + }, + { + "cfn_type": "AWS::Synthetics::Group", + "mappings": [], + "operation": "DeleteGroup", + "phase": "delete", + "service": "synthetics" + }, + { + "cfn_type": "AWS::Timestream::Database", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + } + ], + "operation": "CreateDatabase", + "phase": "create", + "service": "timestream-write" + }, + { + "cfn_type": "AWS::Timestream::Database", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + } + ], + "operation": "DeleteDatabase", + "phase": "delete", + "service": "timestream-write" + }, + { + "cfn_type": "AWS::Timestream::InfluxDBCluster", + "mappings": [ + { + "source": "allocatedStorage", + "target": "AllocatedStorage" + }, + { + "source": "bucket", + "target": "Bucket" + }, + { + "source": "dbInstanceType", + "target": "DbInstanceType" + }, + { + "source": "dbParameterGroupIdentifier", + "target": "DbParameterGroupIdentifier" + }, + { + "source": "dbStorageType", + "target": "DbStorageType" + }, + { + "source": "deploymentType", + "target": "DeploymentType" + }, + { + "source": "failoverMode", + "target": "FailoverMode" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "networkType", + "target": "NetworkType" + }, + { + "source": "organization", + "target": "Organization" + }, + { + "source": "password", + "target": "Password" + }, + { + "source": "port", + "target": "Port" + }, + { + "source": "publiclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "username", + "target": "Username" + }, + { + "source": "vpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + }, + { + "source": "vpcSubnetIds", + "target": "VpcSubnetIds" + } + ], + "operation": "CreateDbCluster", + "phase": "create", + "service": "timestream-influxdb" + }, + { + "cfn_type": "AWS::Timestream::InfluxDBInstance", + "mappings": [ + { + "source": "allocatedStorage", + "target": "AllocatedStorage" + }, + { + "source": "bucket", + "target": "Bucket" + }, + { + "source": "dbInstanceType", + "target": "DbInstanceType" + }, + { + "source": "dbParameterGroupIdentifier", + "target": "DbParameterGroupIdentifier" + }, + { + "source": "dbStorageType", + "target": "DbStorageType" + }, + { + "source": "deploymentType", + "target": "DeploymentType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "networkType", + "target": "NetworkType" + }, + { + "source": "organization", + "target": "Organization" + }, + { + "source": "password", + "target": "Password" + }, + { + "source": "port", + "target": "Port" + }, + { + "source": "publiclyAccessible", + "target": "PubliclyAccessible" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "username", + "target": "Username" + }, + { + "source": "vpcSecurityGroupIds", + "target": "VpcSecurityGroupIds" + }, + { + "source": "vpcSubnetIds", + "target": "VpcSubnetIds" + } + ], + "operation": "CreateDbInstance", + "phase": "create", + "service": "timestream-influxdb" + }, + { + "cfn_type": "AWS::Timestream::ScheduledQuery", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "ClientToken", + "target": "ClientToken" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "Name", + "target": "ScheduledQueryName" + }, + { + "source": "QueryString", + "target": "QueryString" + }, + { + "source": "ScheduledQueryExecutionRoleArn", + "target": "ScheduledQueryExecutionRoleArn" + } + ], + "operation": "CreateScheduledQuery", + "phase": "create", + "service": "timestream-query" + }, + { + "cfn_type": "AWS::Timestream::ScheduledQuery", + "mappings": [], + "operation": "DeleteScheduledQuery", + "phase": "delete", + "service": "timestream-query" + }, + { + "cfn_type": "AWS::Timestream::Table", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "TableName", + "target": "TableName" + } + ], + "operation": "CreateTable", + "phase": "create", + "service": "timestream-write" + }, + { + "cfn_type": "AWS::Timestream::Table", + "mappings": [ + { + "source": "DatabaseName", + "target": "DatabaseName" + }, + { + "source": "TableName", + "target": "TableName" + } + ], + "operation": "DeleteTable", + "phase": "delete", + "service": "timestream-write" + }, + { + "cfn_type": "AWS::Transcribe::VocabularyFilter", + "mappings": [ + { + "source": "DataAccessRoleArn", + "target": "DataAccessRoleArn" + }, + { + "source": "LanguageCode", + "target": "LanguageCode" + }, + { + "source": "VocabularyFilterFileUri", + "target": "VocabularyFilterFileUri" + }, + { + "source": "VocabularyFilterName", + "target": "VocabularyFilterName" + }, + { + "source": "Words", + "target": "Words" + } + ], + "operation": "CreateVocabularyFilter", + "phase": "create", + "service": "transcribe" + }, + { + "cfn_type": "AWS::Transcribe::VocabularyFilter", + "mappings": [ + { + "source": "VocabularyFilterName", + "target": "VocabularyFilterName" + } + ], + "operation": "DeleteVocabularyFilter", + "phase": "delete", + "service": "transcribe" + }, + { + "cfn_type": "AWS::Transfer::Agreement", + "mappings": [ + { + "source": "AccessRole", + "target": "AccessRole" + }, + { + "source": "BaseDirectory", + "target": "BaseDirectory" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "EnforceMessageSigning", + "target": "EnforceMessageSigning" + }, + { + "source": "LocalProfileId", + "target": "LocalProfileId" + }, + { + "source": "PartnerProfileId", + "target": "PartnerProfileId" + }, + { + "source": "PreserveFilename", + "target": "PreserveFilename" + }, + { + "source": "ServerId", + "target": "ServerId" + }, + { + "source": "Status", + "target": "Status" + } + ], + "operation": "CreateAgreement", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Agreement", + "mappings": [ + { + "source": "ServerId", + "target": "ServerId" + } + ], + "operation": "DeleteAgreement", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Certificate", + "mappings": [ + { + "source": "Certificate", + "target": "Certificate" + }, + { + "source": "CertificateChain", + "target": "CertificateChain" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "PrivateKey", + "target": "PrivateKey" + }, + { + "source": "Usage", + "target": "Usage" + } + ], + "operation": "ImportCertificate", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Certificate", + "mappings": [], + "operation": "DeleteCertificate", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Connector", + "mappings": [ + { + "source": "AccessRole", + "target": "AccessRole" + }, + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "LoggingRole", + "target": "LoggingRole" + }, + { + "source": "SecurityPolicyName", + "target": "SecurityPolicyName" + }, + { + "source": "Url", + "target": "Url" + } + ], + "operation": "CreateConnector", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Connector", + "mappings": [], + "operation": "DeleteConnector", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::HostKey", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "HostKeyBody", + "target": "HostKeyBody" + }, + { + "source": "ServerId", + "target": "ServerId" + } + ], + "operation": "ImportHostKey", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::HostKey", + "mappings": [ + { + "source": "ServerId", + "target": "ServerId" + } + ], + "operation": "DeleteHostKey", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Profile", + "mappings": [ + { + "source": "As2Id", + "target": "As2Id" + }, + { + "source": "CertificateIds", + "target": "CertificateIds" + }, + { + "source": "ProfileType", + "target": "ProfileType" + } + ], + "operation": "CreateProfile", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Profile", + "mappings": [], + "operation": "DeleteProfile", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Server", + "mappings": [ + { + "source": "Certificate", + "target": "Certificate" + }, + { + "source": "Domain", + "target": "Domain" + }, + { + "source": "EndpointType", + "target": "EndpointType" + }, + { + "source": "IdentityProviderType", + "target": "IdentityProviderType" + }, + { + "source": "IpAddressType", + "target": "IpAddressType" + }, + { + "source": "LoggingRole", + "target": "LoggingRole" + }, + { + "source": "PostAuthenticationLoginBanner", + "target": "PostAuthenticationLoginBanner" + }, + { + "source": "PreAuthenticationLoginBanner", + "target": "PreAuthenticationLoginBanner" + }, + { + "source": "Protocols", + "target": "Protocols" + }, + { + "source": "SecurityPolicyName", + "target": "SecurityPolicyName" + }, + { + "source": "StructuredLogDestinations", + "target": "StructuredLogDestinations" + } + ], + "operation": "CreateServer", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Server", + "mappings": [], + "operation": "DeleteServer", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::User", + "mappings": [ + { + "source": "HomeDirectory", + "target": "HomeDirectory" + }, + { + "source": "HomeDirectoryType", + "target": "HomeDirectoryType" + }, + { + "source": "Policy", + "target": "Policy" + }, + { + "source": "Role", + "target": "Role" + }, + { + "source": "ServerId", + "target": "ServerId" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "CreateUser", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::User", + "mappings": [ + { + "source": "ServerId", + "target": "ServerId" + }, + { + "source": "UserName", + "target": "UserName" + } + ], + "operation": "DeleteUser", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::WebApp", + "mappings": [ + { + "source": "AccessEndpoint", + "target": "AccessEndpoint" + }, + { + "source": "WebAppEndpointPolicy", + "target": "WebAppEndpointPolicy" + } + ], + "operation": "CreateWebApp", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::WebApp", + "mappings": [], + "operation": "DeleteWebApp", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Workflow", + "mappings": [ + { + "source": "Description", + "target": "Description" + } + ], + "operation": "CreateWorkflow", + "phase": "create", + "service": "transfer" + }, + { + "cfn_type": "AWS::Transfer::Workflow", + "mappings": [], + "operation": "DeleteWorkflow", + "phase": "delete", + "service": "transfer" + }, + { + "cfn_type": "AWS::VerifiedPermissions::IdentitySource", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "policyStoreId", + "target": "PolicyStoreId" + }, + { + "source": "principalEntityType", + "target": "PrincipalEntityType" + } + ], + "operation": "CreateIdentitySource", + "phase": "create", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::IdentitySource", + "mappings": [ + { + "source": "policyStoreId", + "target": "PolicyStoreId" + } + ], + "operation": "DeleteIdentitySource", + "phase": "delete", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::Policy", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "policyStoreId", + "target": "PolicyStoreId" + } + ], + "operation": "CreatePolicy", + "phase": "create", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::Policy", + "mappings": [ + { + "source": "policyStoreId", + "target": "PolicyStoreId" + } + ], + "operation": "DeletePolicy", + "phase": "delete", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::PolicyStore", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreatePolicyStore", + "phase": "create", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::PolicyStore", + "mappings": [], + "operation": "DeletePolicyStore", + "phase": "delete", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::PolicyStoreAlias", + "mappings": [ + { + "source": "aliasName", + "target": "AliasName" + }, + { + "source": "policyStoreId", + "target": "PolicyStoreId" + } + ], + "operation": "CreatePolicyStoreAlias", + "phase": "create", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::PolicyStoreAlias", + "mappings": [ + { + "source": "aliasName", + "target": "AliasName" + } + ], + "operation": "DeletePolicyStoreAlias", + "phase": "delete", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::PolicyTemplate", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "policyStoreId", + "target": "PolicyStoreId" + }, + { + "source": "statement", + "target": "Statement" + } + ], + "operation": "CreatePolicyTemplate", + "phase": "create", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VerifiedPermissions::PolicyTemplate", + "mappings": [ + { + "source": "policyStoreId", + "target": "PolicyStoreId" + } + ], + "operation": "DeletePolicyTemplate", + "phase": "delete", + "service": "verifiedpermissions" + }, + { + "cfn_type": "AWS::VoiceID::Domain", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + } + ], + "operation": "CreateDomain", + "phase": "create", + "service": "voice-id" + }, + { + "cfn_type": "AWS::VoiceID::Domain", + "mappings": [], + "operation": "DeleteDomain", + "phase": "delete", + "service": "voice-id" + }, + { + "cfn_type": "AWS::VpcLattice::AccessLogSubscription", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "destinationArn", + "target": "DestinationArn" + }, + { + "source": "resourceIdentifier", + "target": "ResourceIdentifier" + }, + { + "source": "serviceNetworkLogType", + "target": "ServiceNetworkLogType" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAccessLogSubscription", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::AccessLogSubscription", + "mappings": [], + "operation": "DeleteAccessLogSubscription", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::AuthPolicy", + "mappings": [ + { + "source": "policy", + "target": "Policy" + }, + { + "source": "resourceIdentifier", + "target": "ResourceIdentifier" + } + ], + "operation": "PutAuthPolicy", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::AuthPolicy", + "mappings": [ + { + "source": "resourceIdentifier", + "target": "ResourceIdentifier" + } + ], + "operation": "DeleteAuthPolicy", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::DomainVerification", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "domainName", + "target": "DomainName" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "StartDomainVerification", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::DomainVerification", + "mappings": [], + "operation": "DeleteDomainVerification", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::Listener", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "port", + "target": "Port" + }, + { + "source": "protocol", + "target": "Protocol" + }, + { + "source": "serviceIdentifier", + "target": "ServiceIdentifier" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateListener", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::Listener", + "mappings": [ + { + "source": "serviceIdentifier", + "target": "ServiceIdentifier" + } + ], + "operation": "DeleteListener", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ResourceConfiguration", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "customDomainName", + "target": "CustomDomainName" + }, + { + "source": "groupDomain", + "target": "GroupDomain" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "portRanges", + "target": "PortRanges" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateResourceConfiguration", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ResourceConfiguration", + "mappings": [], + "operation": "DeleteResourceConfiguration", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ResourceGateway", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "ipAddressType", + "target": "IpAddressType" + }, + { + "source": "ipv4AddressesPerEni", + "target": "Ipv4AddressesPerEni" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "resourceConfigDnsResolution", + "target": "ResourceConfigDnsResolution" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcIdentifier", + "target": "VpcIdentifier" + } + ], + "operation": "CreateResourceGateway", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ResourceGateway", + "mappings": [], + "operation": "DeleteResourceGateway", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ResourcePolicy", + "mappings": [ + { + "source": "policy", + "target": "Policy" + }, + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ResourcePolicy", + "mappings": [ + { + "source": "resourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::Rule", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "listenerIdentifier", + "target": "ListenerIdentifier" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "priority", + "target": "Priority" + }, + { + "source": "serviceIdentifier", + "target": "ServiceIdentifier" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateRule", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::Rule", + "mappings": [ + { + "source": "listenerIdentifier", + "target": "ListenerIdentifier" + }, + { + "source": "serviceIdentifier", + "target": "ServiceIdentifier" + } + ], + "operation": "DeleteRule", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::Service", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "authType", + "target": "AuthType" + }, + { + "source": "certificateArn", + "target": "CertificateArn" + }, + { + "source": "customDomainName", + "target": "CustomDomainName" + }, + { + "source": "idleTimeoutSeconds", + "target": "IdleTimeoutSeconds" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateService", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::Service", + "mappings": [], + "operation": "DeleteService", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetwork", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "authType", + "target": "AuthType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateServiceNetwork", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetwork", + "mappings": [], + "operation": "DeleteServiceNetwork", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetworkResourceAssociation", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "privateDnsEnabled", + "target": "PrivateDnsEnabled" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateServiceNetworkResourceAssociation", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetworkResourceAssociation", + "mappings": [], + "operation": "DeleteServiceNetworkResourceAssociation", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetworkServiceAssociation", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "serviceIdentifier", + "target": "ServiceIdentifier" + }, + { + "source": "serviceNetworkIdentifier", + "target": "ServiceNetworkIdentifier" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateServiceNetworkServiceAssociation", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetworkServiceAssociation", + "mappings": [], + "operation": "DeleteServiceNetworkServiceAssociation", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetworkVpcAssociation", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "privateDnsEnabled", + "target": "PrivateDnsEnabled" + }, + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "serviceNetworkIdentifier", + "target": "ServiceNetworkIdentifier" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "vpcIdentifier", + "target": "VpcIdentifier" + } + ], + "operation": "CreateServiceNetworkVpcAssociation", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::ServiceNetworkVpcAssociation", + "mappings": [], + "operation": "DeleteServiceNetworkVpcAssociation", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::TargetGroup", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateTargetGroup", + "phase": "create", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::VpcLattice::TargetGroup", + "mappings": [], + "operation": "DeleteTargetGroup", + "phase": "delete", + "service": "vpc-lattice" + }, + { + "cfn_type": "AWS::WAFv2::IPSet", + "mappings": [ + { + "source": "Addresses", + "target": "Addresses" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "IPAddressVersion", + "target": "IPAddressVersion" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "CreateIPSet", + "phase": "create", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::IPSet", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "DeleteIPSet", + "phase": "delete", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::LoggingConfiguration", + "mappings": [ + { + "source": "ResourceArn", + "target": "ResourceArn" + } + ], + "operation": "DeleteLoggingConfiguration", + "phase": "delete", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::RegexPatternSet", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "CreateRegexPatternSet", + "phase": "create", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::RegexPatternSet", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "DeleteRegexPatternSet", + "phase": "delete", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::RuleGroup", + "mappings": [ + { + "source": "Capacity", + "target": "Capacity" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "CreateRuleGroup", + "phase": "create", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::RuleGroup", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "DeleteRuleGroup", + "phase": "delete", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::WebACL", + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + }, + { + "source": "TokenDomains", + "target": "TokenDomains" + } + ], + "operation": "CreateWebACL", + "phase": "create", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WAFv2::WebACL", + "mappings": [ + { + "source": "Name", + "target": "Name" + }, + { + "source": "Scope", + "target": "Scope" + } + ], + "operation": "DeleteWebACL", + "phase": "delete", + "service": "wafv2" + }, + { + "cfn_type": "AWS::WellArchitected::Lens", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "JSONString", + "target": "JSONString" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "ImportLens", + "phase": "create", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::Lens", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [], + "operation": "DeleteLens", + "phase": "delete", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::Profile", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "ProfileDescription", + "target": "ProfileDescription" + }, + { + "source": "ProfileName", + "target": "ProfileName" + }, + { + "source": "Tags", + "target": "Tags" + } + ], + "operation": "CreateProfile", + "phase": "create", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::Profile", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [], + "operation": "DeleteProfile", + "phase": "delete", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::ReviewTemplate", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "Description", + "target": "Description" + }, + { + "source": "Lenses", + "target": "Lenses" + }, + { + "source": "Notes", + "target": "Notes" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "TemplateName", + "target": "TemplateName" + } + ], + "operation": "CreateReviewTemplate", + "phase": "create", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::ReviewTemplate", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [], + "operation": "DeleteReviewTemplate", + "phase": "delete", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::Workload", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [ + { + "source": "AccountIds", + "target": "AccountIds" + }, + { + "source": "ArchitecturalDesign", + "target": "ArchitecturalDesign" + }, + { + "source": "AwsRegions", + "target": "AwsRegions" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "Environment", + "target": "Environment" + }, + { + "source": "Industry", + "target": "Industry" + }, + { + "source": "IndustryType", + "target": "IndustryType" + }, + { + "source": "Lenses", + "target": "Lenses" + }, + { + "source": "NonAwsRegions", + "target": "NonAwsRegions" + }, + { + "source": "Notes", + "target": "Notes" + }, + { + "source": "ReviewOwner", + "target": "ReviewOwner" + }, + { + "source": "Tags", + "target": "Tags" + }, + { + "source": "WorkloadName", + "target": "WorkloadName" + } + ], + "operation": "CreateWorkload", + "phase": "create", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::WellArchitected::Workload", + "ignored_inputs": [ + "ClientRequestToken" + ], + "mappings": [], + "operation": "DeleteWorkload", + "phase": "delete", + "service": "wellarchitected" + }, + { + "cfn_type": "AWS::Wickr::Network", + "mappings": [ + { + "source": "accessLevel", + "target": "AccessLevel" + }, + { + "source": "networkName", + "target": "NetworkName" + } + ], + "operation": "CreateNetwork", + "phase": "create", + "service": "wickr" + }, + { + "cfn_type": "AWS::Wickr::Network", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteNetwork", + "phase": "delete", + "service": "wickr" + }, + { + "cfn_type": "AWS::Wisdom::AIAgent", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateAIAgent", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIAgent", + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAIAgent", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIAgentVersion", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "aiAgentId", + "target": "AIAgentId" + }, + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "CreateAIAgentVersion", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIAgentVersion", + "mappings": [ + { + "source": "aiAgentId", + "target": "AIAgentId" + }, + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAIAgentVersion", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIGuardrail", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + }, + { + "source": "blockedInputMessaging", + "target": "BlockedInputMessaging" + }, + { + "source": "blockedOutputsMessaging", + "target": "BlockedOutputsMessaging" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + } + ], + "operation": "CreateAIGuardrail", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIGuardrail", + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAIGuardrail", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIGuardrailVersion", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "aiGuardrailId", + "target": "AIGuardrailId" + }, + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "CreateAIGuardrailVersion", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIGuardrailVersion", + "mappings": [ + { + "source": "aiGuardrailId", + "target": "AIGuardrailId" + }, + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAIGuardrailVersion", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIPrompt", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "apiFormat", + "target": "ApiFormat" + }, + { + "source": "assistantId", + "target": "AssistantId" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "modelId", + "target": "ModelId" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "templateType", + "target": "TemplateType" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateAIPrompt", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIPrompt", + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAIPrompt", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIPromptVersion", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "aiPromptId", + "target": "AIPromptId" + }, + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "CreateAIPromptVersion", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::AIPromptVersion", + "mappings": [ + { + "source": "aiPromptId", + "target": "AIPromptId" + }, + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAIPromptVersion", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::Assistant", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + }, + { + "source": "type", + "target": "Type" + } + ], + "operation": "CreateAssistant", + "phase": "create", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::Assistant", + "mappings": [], + "operation": "DeleteAssistant", + "phase": "delete", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::AssistantAssociation", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + }, + { + "source": "associationType", + "target": "AssociationType" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateAssistantAssociation", + "phase": "create", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::AssistantAssociation", + "mappings": [ + { + "source": "assistantId", + "target": "AssistantId" + } + ], + "operation": "DeleteAssistantAssociation", + "phase": "delete", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::KnowledgeBase", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "description", + "target": "Description" + }, + { + "source": "knowledgeBaseType", + "target": "KnowledgeBaseType" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateKnowledgeBase", + "phase": "create", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::KnowledgeBase", + "mappings": [], + "operation": "DeleteKnowledgeBase", + "phase": "delete", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::MessageTemplate", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "channelSubtype", + "target": "ChannelSubtype" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "language", + "target": "Language" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateMessageTemplate", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::MessageTemplate", + "mappings": [], + "operation": "DeleteMessageTemplate", + "phase": "delete", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::MessageTemplateVersion", + "mappings": [ + { + "source": "messageTemplateContentSha256", + "target": "MessageTemplateContentSha256" + } + ], + "operation": "CreateMessageTemplateVersion", + "phase": "create", + "service": "qconnect" + }, + { + "cfn_type": "AWS::Wisdom::QuickResponse", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "channels", + "target": "Channels" + }, + { + "source": "contentType", + "target": "ContentType" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "isActive", + "target": "IsActive" + }, + { + "source": "language", + "target": "Language" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "shortcutKey", + "target": "ShortcutKey" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateQuickResponse", + "phase": "create", + "service": "wisdom" + }, + { + "cfn_type": "AWS::Wisdom::QuickResponse", + "mappings": [], + "operation": "DeleteQuickResponse", + "phase": "delete", + "service": "wisdom" + }, + { + "cfn_type": "AWS::WorkSpaces::ConnectionAlias", + "mappings": [ + { + "source": "ConnectionString", + "target": "ConnectionString" + } + ], + "operation": "CreateConnectionAlias", + "phase": "create", + "service": "workspaces" + }, + { + "cfn_type": "AWS::WorkSpaces::ConnectionAlias", + "mappings": [], + "operation": "DeleteConnectionAlias", + "phase": "delete", + "service": "workspaces" + }, + { + "cfn_type": "AWS::WorkSpaces::Workspace", + "mappings": [], + "operation": "TerminateWorkspaces", + "phase": "delete", + "service": "workspaces" + }, + { + "cfn_type": "AWS::WorkSpaces::WorkspaceIpGroup", + "mappings": [ + { + "source": "GroupDesc", + "target": "GroupDesc" + }, + { + "source": "GroupName", + "target": "GroupName" + } + ], + "operation": "CreateIpGroup", + "phase": "create", + "service": "workspaces" + }, + { + "cfn_type": "AWS::WorkSpaces::WorkspacesPool", + "mappings": [ + { + "source": "BundleId", + "target": "BundleId" + }, + { + "source": "Description", + "target": "Description" + }, + { + "source": "DirectoryId", + "target": "DirectoryId" + }, + { + "source": "PoolName", + "target": "PoolName" + }, + { + "source": "RunningMode", + "target": "RunningMode" + } + ], + "operation": "CreateWorkspacesPool", + "phase": "create", + "service": "workspaces" + }, + { + "cfn_type": "AWS::WorkSpaces::WorkspacesPool", + "mappings": [], + "operation": "TerminateWorkspacesPool", + "phase": "delete", + "service": "workspaces" + }, + { + "cfn_type": "AWS::WorkSpacesThinClient::Environment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "desiredSoftwareSetId", + "target": "DesiredSoftwareSetId" + }, + { + "source": "desktopArn", + "target": "DesktopArn" + }, + { + "source": "desktopEndpoint", + "target": "DesktopEndpoint" + }, + { + "source": "kmsKeyArn", + "target": "KmsKeyArn" + }, + { + "source": "name", + "target": "Name" + }, + { + "source": "softwareSetUpdateMode", + "target": "SoftwareSetUpdateMode" + }, + { + "source": "softwareSetUpdateSchedule", + "target": "SoftwareSetUpdateSchedule" + }, + { + "source": "tags", + "target": "Tags" + } + ], + "operation": "CreateEnvironment", + "phase": "create", + "service": "workspaces-thin-client" + }, + { + "cfn_type": "AWS::WorkSpacesThinClient::Environment", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [], + "operation": "DeleteEnvironment", + "phase": "delete", + "service": "workspaces-thin-client" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::BrowserSettings", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "browserPolicy", + "target": "BrowserPolicy" + }, + { + "source": "customerManagedKey", + "target": "CustomerManagedKey" + } + ], + "operation": "CreateBrowserSettings", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::BrowserSettings", + "mappings": [], + "operation": "DeleteBrowserSettings", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::DataProtectionSettings", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "customerManagedKey", + "target": "CustomerManagedKey" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + } + ], + "operation": "CreateDataProtectionSettings", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::DataProtectionSettings", + "mappings": [], + "operation": "DeleteDataProtectionSettings", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::IdentityProvider", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "identityProviderName", + "target": "IdentityProviderName" + }, + { + "source": "identityProviderType", + "target": "IdentityProviderType" + }, + { + "source": "portalArn", + "target": "PortalArn" + } + ], + "operation": "CreateIdentityProvider", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::IdentityProvider", + "mappings": [], + "operation": "DeleteIdentityProvider", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::IpAccessSettings", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "customerManagedKey", + "target": "CustomerManagedKey" + }, + { + "source": "description", + "target": "Description" + }, + { + "source": "displayName", + "target": "DisplayName" + } + ], + "operation": "CreateIpAccessSettings", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::IpAccessSettings", + "mappings": [], + "operation": "DeleteIpAccessSettings", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::NetworkSettings", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "securityGroupIds", + "target": "SecurityGroupIds" + }, + { + "source": "subnetIds", + "target": "SubnetIds" + }, + { + "source": "vpcId", + "target": "VpcId" + } + ], + "operation": "CreateNetworkSettings", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::NetworkSettings", + "mappings": [], + "operation": "DeleteNetworkSettings", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::Portal", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "authenticationType", + "target": "AuthenticationType" + }, + { + "source": "customerManagedKey", + "target": "CustomerManagedKey" + }, + { + "source": "displayName", + "target": "DisplayName" + }, + { + "source": "instanceType", + "target": "InstanceType" + }, + { + "source": "maxConcurrentSessions", + "target": "MaxConcurrentSessions" + }, + { + "source": "portalCustomDomain", + "target": "PortalCustomDomain" + } + ], + "operation": "CreatePortal", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::Portal", + "mappings": [], + "operation": "DeletePortal", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::SessionLogger", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "customerManagedKey", + "target": "CustomerManagedKey" + }, + { + "source": "displayName", + "target": "DisplayName" + } + ], + "operation": "CreateSessionLogger", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::SessionLogger", + "mappings": [], + "operation": "DeleteSessionLogger", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::TrustStore", + "mappings": [], + "operation": "DeleteTrustStore", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::UserAccessLoggingSettings", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "kinesisStreamArn", + "target": "KinesisStreamArn" + } + ], + "operation": "CreateUserAccessLoggingSettings", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::UserAccessLoggingSettings", + "mappings": [], + "operation": "DeleteUserAccessLoggingSettings", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::UserSettings", + "ignored_inputs": [ + "clientToken" + ], + "mappings": [ + { + "source": "copyAllowed", + "target": "CopyAllowed" + }, + { + "source": "customerManagedKey", + "target": "CustomerManagedKey" + }, + { + "source": "deepLinkAllowed", + "target": "DeepLinkAllowed" + }, + { + "source": "disconnectTimeoutInMinutes", + "target": "DisconnectTimeoutInMinutes" + }, + { + "source": "downloadAllowed", + "target": "DownloadAllowed" + }, + { + "source": "idleDisconnectTimeoutInMinutes", + "target": "IdleDisconnectTimeoutInMinutes" + }, + { + "source": "pasteAllowed", + "target": "PasteAllowed" + }, + { + "source": "printAllowed", + "target": "PrintAllowed" + }, + { + "source": "uploadAllowed", + "target": "UploadAllowed" + }, + { + "source": "webAuthnAllowed", + "target": "WebAuthnAllowed" + } + ], + "operation": "CreateUserSettings", + "phase": "create", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkSpacesWeb::UserSettings", + "mappings": [], + "operation": "DeleteUserSettings", + "phase": "delete", + "service": "workspaces-web" + }, + { + "cfn_type": "AWS::WorkspacesInstances::Volume", + "ignored_inputs": [ + "ClientToken" + ], + "mappings": [ + { + "source": "AvailabilityZone", + "target": "AvailabilityZone" + }, + { + "source": "Encrypted", + "target": "Encrypted" + }, + { + "source": "Iops", + "target": "Iops" + }, + { + "source": "KmsKeyId", + "target": "KmsKeyId" + }, + { + "source": "SizeInGB", + "target": "SizeInGB" + }, + { + "source": "SnapshotId", + "target": "SnapshotId" + }, + { + "source": "Throughput", + "target": "Throughput" + }, + { + "source": "VolumeType", + "target": "VolumeType" + } + ], + "operation": "CreateVolume", + "phase": "create", + "service": "workspaces-instances" + }, + { + "cfn_type": "AWS::WorkspacesInstances::Volume", + "mappings": [], + "operation": "DeleteVolume", + "phase": "delete", + "service": "workspaces-instances" + }, + { + "cfn_type": "AWS::WorkspacesInstances::VolumeAssociation", + "mappings": [ + { + "source": "Device", + "target": "Device" + }, + { + "source": "VolumeId", + "target": "VolumeId" + }, + { + "source": "WorkspaceInstanceId", + "target": "WorkspaceInstanceId" + } + ], + "operation": "AssociateVolume", + "phase": "create", + "service": "workspaces-instances" + }, + { + "cfn_type": "AWS::WorkspacesInstances::VolumeAssociation", + "mappings": [ + { + "source": "Device", + "target": "Device" + }, + { + "source": "DisassociateMode", + "target": "DisassociateMode" + }, + { + "source": "VolumeId", + "target": "VolumeId" + }, + { + "source": "WorkspaceInstanceId", + "target": "WorkspaceInstanceId" + } + ], + "operation": "DisassociateVolume", + "phase": "delete", + "service": "workspaces-instances" + }, + { + "cfn_type": "AWS::WorkspacesInstances::WorkspaceInstance", + "mappings": [], + "operation": "DeleteWorkspaceInstance", + "phase": "delete", + "service": "workspaces-instances" + }, + { + "cfn_type": "AWS::XRay::Group", + "mappings": [ + { + "source": "FilterExpression", + "target": "FilterExpression" + }, + { + "source": "GroupName", + "target": "GroupName" + } + ], + "operation": "CreateGroup", + "phase": "create", + "service": "xray" + }, + { + "cfn_type": "AWS::XRay::Group", + "mappings": [ + { + "source": "GroupName", + "target": "GroupName" + } + ], + "operation": "DeleteGroup", + "phase": "delete", + "service": "xray" + }, + { + "cfn_type": "AWS::XRay::ResourcePolicy", + "mappings": [ + { + "source": "BypassPolicyLockoutCheck", + "target": "BypassPolicyLockoutCheck" + }, + { + "source": "PolicyDocument", + "target": "PolicyDocument" + }, + { + "source": "PolicyName", + "target": "PolicyName" + } + ], + "operation": "PutResourcePolicy", + "phase": "create", + "service": "xray" + }, + { + "cfn_type": "AWS::XRay::ResourcePolicy", + "mappings": [ + { + "source": "PolicyName", + "target": "PolicyName" + } + ], + "operation": "DeleteResourcePolicy", + "phase": "delete", + "service": "xray" + }, + { + "cfn_type": "AWS::XRay::SamplingRule", + "mappings": [ + { + "source": "RuleName", + "target": "RuleName" + } + ], + "operation": "DeleteSamplingRule", + "phase": "delete", + "service": "xray" + } + ], + "format_version": 1, + "source": { + "botocore_service_count": 431, + "botocore_version": "2.0.0dev155", + "compiled_schemas_sha256": "76bcee337b3f10bb9d72cbbe836d0c89afbb96a05c2d37c18eebf65685fbabb5", + "compiled_type_count": 1731, + "provider_schemas_sha256": "929767f603b6744fda6741ba5ca5ec42b54847a4f9a07402369ebecd8ce82248", + "provider_type_count": 1729 + } +} diff --git a/src/data-source/scripts/generate_aws_api_catalog.py b/src/data-source/scripts/generate_aws_api_catalog.py new file mode 100644 index 00000000..d98445e6 --- /dev/null +++ b/src/data-source/scripts/generate_aws_api_catalog.py @@ -0,0 +1,983 @@ +#!/usr/bin/env python3 +"""Generate the AWS API operation adapter catalog for validation-engine. + +Derives CloudFormation-type -> API-operation adapters from two public sources: + +1. CloudFormation resource provider schemas WITH handler metadata + (https://github.com/aws-cloudformation/resource-provider-enhanced-schemas + releases, ``schemas-standard.zip``). Each type's own create/delete handler + permissions contain the type's canonical lifecycle API actions. +2. Botocore service models (importable ``botocore``), which resolve IAM action + prefixes to real services and operations and provide exact input shapes. + +Derivation direction is type -> operation, scoped to one type's own handler +permissions at a time. The global inverse (operation -> type by name) is +unsafe and is never used. Every candidate must pass all of: + +- service identity tiering: the action must belong to the type's own service + (botocore service name match beats IAM-prefix match beats signing-identity + match beats substring; lower tiers are dropped when a higher tier exists) +- lifecycle verb family match for the handler role +- structural verification: operation input members must map onto writable + properties of the type in the validator's OWN compiled schemas (verbatim, + or via the reviewed identifier-rename rules below) +- noun agreement or property-overlap thresholds; ties are dropped entirely +- global reverse uniqueness: one (service, operation) key maps to exactly one + catalog entry; unresolvable collisions are dropped entirely + +Types or operations that fail any gate are omitted: an uncovered operation is +validated as SKIPPED at runtime, never guessed. + +Usage: + python3 generate_aws_api_catalog.py \ + --botocore-root /path/to/botocore \ + --provider-schemas schemas-standard.zip \ + --compiled-schemas ../generated/schema-validator/compiled_schemas.json \ + --output ../generated/data/aws_api_operation_catalog.json +""" + +import argparse +import hashlib +import importlib +import json +import subprocess +import sys +import zipfile +from collections import defaultdict +from pathlib import Path + +FORMAT_VERSION = 1 + +# Multiple provider types can list the same underlying operation. Keep a +# collision only when the API action itself names one uniquely correct type; +# every unreviewed or representation-version collision is dropped. +COLLISION_PREFERENCES = { + ('dynamodb', 'CreateTable'): 'AWS::DynamoDB::Table', + ('ec2', 'CreateTransitGatewayVpcAttachment'): + 'AWS::EC2::TransitGatewayVpcAttachment', + ('eks', 'CreateAccessEntry'): 'AWS::EKS::AccessEntry', +} + +CREATE_VERBS = ( + 'create', 'put', 'register', 'add', 'allocate', 'provision', 'launch', + 'run', 'import', 'request', 'publish', 'set', 'establish', + 'associate', 'attach', 'enable', 'deploy', 'subscribe', 'purchase', + 'copy', 'initialize', 'define', 'build', 'issue', 'schedule', 'submit', + 'grant', 'start', +) +DELETE_VERBS = ( + 'delete', 'remove', 'deregister', 'release', 'terminate', 'cancel', + 'disassociate', 'detach', 'revoke', 'deprovision', 'destroy', + 'unsubscribe', 'purge', +) + +# CFN service segments whose IAM/service identity differs beyond casing. +SEGMENT_ALIASES = { + 'msk': 'kafka', + 'opensearchservice': 'es', + 'certificatemanager': 'acm', + 'elasticloadbalancingv2': 'elasticloadbalancing', + 'ses': 'sesv2', +} + +# Services handled by dedicated validation paths; adapters must not shadow them. +EXCLUDED_SERVICES = frozenset({'cloudformation', 'cloudcontrol'}) + +# Hand-reviewed update adapters. Update APIs carry partial state, so update +# entries are curated rather than derived; each is verified like derived ones. +CURATED_UPDATE_ADAPTERS = [ + { + 'cfn_type': 'AWS::Lambda::Function', + 'service': 'lambda', + 'operation': 'UpdateFunctionConfiguration', + 'phase': 'update', + 'mappings': [ + {'source': 'Runtime', 'target': 'Runtime'}, + {'source': 'Role', 'target': 'Role'}, + {'source': 'Handler', 'target': 'Handler'}, + {'source': 'Description', 'target': 'Description'}, + {'source': 'Timeout', 'target': 'Timeout'}, + {'source': 'MemorySize', 'target': 'MemorySize'}, + ], + 'ignored_inputs': ['FunctionName'], + }, +] + +# Operations that mutate runtime state without representing desired-state +# creation. The generator fails if a derivation ever selects one of these. +FORBIDDEN_OPERATIONS = frozenset({ + ('ecs', 'RunTask'), + ('ec2', 'StartInstances'), + ('ec2', 'StopInstances'), + ('ec2', 'RebootInstances'), + ('iot', 'StartThingRegistrationTask'), + ('lambda', 'Invoke'), + ('sns', 'Publish'), + ('sqs', 'SendMessage'), + ('s3', 'PutObject'), + ('dynamodb', 'PutItem'), + ('logs', 'StartQuery'), + ('acm', 'RemoveTagsFromCertificate'), + ('robomaker', 'DeregisterRobot'), + ('quicksight', 'CreateTopic'), + ('quicksight', 'DeleteTopic'), +}) + +# Explicit input member names safe to ignore during all-or-nothing synthesis. +# These are request-control fields that do not represent desired resource state. +# Detection: by exact name match from this curated set, or botocore shape +# metadata (idempotencyToken trait). +IGNORED_INPUT_NAMES = frozenset({ + 'ClientToken', + 'ClientRequestToken', + 'IdempotencyToken', + 'RequestToken', + 'DryRun', +}) + + +def _ignored_inputs_for_operation(members, phase, service, operation): + """Determine which input members are safe to ignore. + + Returns a sorted list of member names that the runtime can discard without + affecting state validation. Only exact name matches against the curated + request-control set and botocore idempotency-token metadata qualify. + """ + ignored = set() + for name, shape in members.items(): + if name in IGNORED_INPUT_NAMES: + ignored.add(name) + elif getattr(shape, 'metadata', None) and shape.metadata.get( + 'idempotencyToken' + ): + ignored.add(name) + elif hasattr(shape, 'serialization') and isinstance( + shape.serialization, dict + ) and shape.serialization.get('idempotencyToken'): + ignored.add(name) + return sorted(ignored) + + +# Known-good pairs the derivation must reproduce exactly; guards regressions +# in the derivation rules themselves. +EXPECTED_PAIRS = { + 'AWS::S3::Bucket': ('s3', 'CreateBucket'), + 'AWS::DynamoDB::Table': ('dynamodb', 'CreateTable'), + 'AWS::IAM::Role': ('iam', 'CreateRole'), + 'AWS::Lambda::Function': ('lambda', 'CreateFunction'), + 'AWS::SNS::Topic': ('sns', 'CreateTopic'), + 'AWS::SQS::Queue': ('sqs', 'CreateQueue'), + 'AWS::EC2::Instance': ('ec2', 'RunInstances'), + 'AWS::EC2::VPC': ('ec2', 'CreateVpc'), + 'AWS::KMS::Key': ('kms', 'CreateKey'), + 'AWS::Logs::LogGroup': ('logs', 'CreateLogGroup'), + 'AWS::CloudWatch::Alarm': ('cloudwatch', 'PutMetricAlarm'), + 'AWS::StepFunctions::StateMachine': ('stepfunctions', 'CreateStateMachine'), + 'AWS::Kinesis::Stream': ('kinesis', 'CreateStream'), + 'AWS::SecretsManager::Secret': ('secretsmanager', 'CreateSecret'), + 'AWS::ElasticLoadBalancingV2::LoadBalancer': ('elbv2', 'CreateLoadBalancer'), +} + + +def _parse_args(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--botocore-root', required=True, type=Path) + parser.add_argument('--provider-schemas', required=True, type=Path) + parser.add_argument('--compiled-schemas', required=True, type=Path) + parser.add_argument('--output', required=True, type=Path) + return parser.parse_args() + + +def _normalize(value): + return ''.join(c for c in value.lower() if c.isalnum()) + + +class BotocoreIndex: + """Resolves IAM action prefixes to concrete botocore operations.""" + + def __init__(self): + botocore_session = importlib.import_module('botocore.session') + self._session = botocore_session.Session() + self._identities = {} + self._operations = {} + self._by_identity = defaultdict(set) + for service in self._session.get_available_services(): + model = self._session.get_service_model(service) + identities = { + _normalize(value) + for value in ( + service, + model.endpoint_prefix or '', + model.signing_name or '', + str(getattr(model, 'service_id', '') or ''), + ) + if value + } + self._identities[service] = identities + for identity in identities: + self._by_identity[identity].add(service) + self._operations[service] = { + op.lower(): op for op in model.operation_names + } + + @property + def service_count(self): + return len(self._operations) + + @property + def operation_count(self): + """Total number of operations across all services.""" + return sum(len(ops) for ops in self._operations.values()) + + def input_members(self, service, operation): + model = self._session.get_service_model(service) + shape = model.operation_model(operation).input_shape + return dict(shape.members) if shape else {} + + def resolve(self, action_prefix, action_name): + """Every (service, operation) the action can denote.""" + resolved = set() + for service in self._by_identity.get(action_prefix, ()): + operation = self._operations[service].get(action_name.lower()) + if operation: + resolved.add((service, operation)) + if resolved: + return resolved + for identity, services in self._by_identity.items(): + if action_prefix in identity or identity in action_prefix: + for service in services: + operation = self._operations[service].get( + action_name.lower() + ) + if operation: + resolved.add((service, operation)) + return resolved + + def identity_tier(self, action_prefix, service, segment_aliases): + """Lower is a stronger identity match; None means unrelated.""" + if _normalize(service) in segment_aliases: + return 0 + if action_prefix in segment_aliases: + return 1 + if self._identities[service] & segment_aliases: + return 2 + if any( + action_prefix in alias or alias in action_prefix + for alias in segment_aliases + ): + return 3 + return None + + +def _verb_rank(operation, verbs): + lowered = operation.lower() + for index, verb in enumerate(verbs): + if lowered.startswith(verb): + return index + return None + + +def _noun_matches(operation, resource_segment): + normalized = _normalize(operation) + if normalized.endswith(resource_segment): + return True + if normalized.endswith(resource_segment + 's'): + return True + if resource_segment.endswith('y') and normalized.endswith( + resource_segment[:-1] + 'ies' + ): + return True + return False + + +def _source_sha256(source_path): + digest = hashlib.sha256() + if source_path.is_file(): + digest.update(source_path.read_bytes()) + return digest.hexdigest() + for path in sorted(source_path.rglob('*.json')): + digest.update(path.relative_to(source_path).as_posix().encode()) + digest.update(b'\0') + digest.update(path.read_bytes()) + return digest.hexdigest() + + +def _load_provider_schemas(source_path): + schemas = {} + if source_path.is_dir(): + documents = ( + (path.as_posix(), path.read_bytes()) + for path in sorted(source_path.rglob('*.json')) + ) + else: + archive = zipfile.ZipFile(source_path) + documents = ( + (name, archive.read(name)) + for name in sorted(archive.namelist()) + if name.endswith('.json') + ) + try: + for _, contents in documents: + try: + schema = json.loads(contents) + except (json.JSONDecodeError, UnicodeDecodeError): + continue + type_name = schema.get('typeName') if isinstance(schema, dict) else None + if type_name and type_name.startswith('AWS::'): + schemas[type_name] = schema + finally: + if not source_path.is_dir(): + archive.close() + return schemas + + +def _compiled_constraints(compiled_schemas, type_name): + schema = compiled_schemas.get(type_name) + if not isinstance(schema, dict): + return None + property_schemas = schema.get('properties') or {} + read_only = set(schema.get('read_only_properties') or []) + primary = set(schema.get('primary_identifier') or []) + definitions = schema.get('definitions') or {} + return property_schemas, read_only, primary, definitions + + +def _resolve_schema_node(node, definitions, seen=frozenset()): + if not isinstance(node, dict): + return {} + reference = node.get('ref_name') + if reference and reference not in seen: + return _resolve_schema_node( + definitions.get(reference), definitions, seen | {reference} + ) + return node + + +def _schema_types(node, definitions): + node = _resolve_schema_node(node, definitions) + schema_type = node.get('type') + if isinstance(schema_type, str): + types = {schema_type} + elif isinstance(schema_type, list): + types = {value for value in schema_type if isinstance(value, str)} + else: + types = set() + for alternatives in ('any_of', 'one_of'): + for alternative in node.get(alternatives) or []: + types.update(_schema_types(alternative, definitions)) + return types + + +def _schema_node_for_type(node, definitions, expected_type): + node = _resolve_schema_node(node, definitions) + if expected_type in _schema_types(node, definitions): + if expected_type in _schema_types( + {key: value for key, value in node.items() + if key not in ('any_of', 'one_of')}, definitions + ): + return node + for alternatives in ('any_of', 'one_of'): + for alternative in node.get(alternatives) or []: + selected = _schema_node_for_type( + alternative, definitions, expected_type + ) + if selected: + return selected + return None + + +def _is_key_value_tag_array(target_schema, definitions): + array_schema = _schema_node_for_type( + target_schema, definitions, 'array' + ) + if not array_schema: + return False + item_schema = _resolve_schema_node( + array_schema.get('items') or {}, definitions + ) + alternatives = [item_schema] + for key in ('any_of', 'one_of'): + alternatives.extend( + _resolve_schema_node(option, definitions) + for option in item_schema.get(key) or [] + ) + return any( + {'Key', 'Value'} <= set(option.get('properties') or {}) + for option in alternatives + ) + + +def _is_runtime_safe_mapping(source_shape, target_schema, definitions, target): + source_type = source_shape.type_name + target_types = _schema_types(target_schema, definitions) + if source_type in ('string', 'boolean'): + return source_type in target_types + if source_type in ('integer', 'long'): + return bool({'integer', 'number'} & target_types) + if source_type in ('float', 'double'): + return 'number' in target_types + if source_type == 'list' and source_shape.member.type_name in ( + 'string', 'boolean', 'integer', 'long', 'float', 'double' + ): + array_schema = _schema_node_for_type( + target_schema, definitions, 'array' + ) + return bool( + array_schema + and _is_runtime_safe_mapping( + source_shape.member, + array_schema.get('items') or {}, + definitions, + target, + ) + ) + if source_type == 'map' and target == 'Tags': + return ( + source_shape.value.type_name == 'string' + and _is_key_value_tag_array(target_schema, definitions) + ) + return False + + +def _property_mappings( + members, property_schemas, writable_by_lower, resource_segment, definitions +): + """Return mappings the runtime can serialize without nested rewriting.""" + mappings = [] + for member in sorted(members): + lowered = member.lower() + target = None + if lowered in writable_by_lower: + target = writable_by_lower[lowered] + elif lowered + 'name' in writable_by_lower: + target = writable_by_lower[lowered + 'name'] + elif lowered == 'name' and resource_segment + 'name' in writable_by_lower: + target = writable_by_lower[resource_segment + 'name'] + if target and _is_runtime_safe_mapping( + members[member], property_schemas[target], definitions, target + ): + mappings.append((member, target)) + return mappings + + +def _derive_role(role, verbs, provider_schemas, compiled_schemas, index, require_mappings): + adapters = {} + counters = defaultdict(int) + for type_name, schema in sorted(provider_schemas.items()): + constraints = _compiled_constraints(compiled_schemas, type_name) + if constraints is None: + counters['type_not_compiled'] += 1 + continue + property_schemas, read_only, primary, definitions = constraints + handlers = schema.get('handlers') + handler = handlers.get(role) if isinstance(handlers, dict) else None + if not isinstance(handler, dict): + counters['no_handler'] += 1 + continue + _, service_segment, resource_segment = type_name.split('::', 2) + service_segment = _normalize(service_segment) + resource_segment = _normalize(resource_segment) + if service_segment in EXCLUDED_SERVICES: + counters['excluded_service'] += 1 + continue + segment_aliases = {service_segment} + if service_segment in SEGMENT_ALIASES: + segment_aliases.add(SEGMENT_ALIASES[service_segment]) + candidates = set() + has_unavailable_exact_lifecycle_operation = False + for action in handler.get('permissions') or []: + if not isinstance(action, str) or ':' not in action: + continue + prefix, action_name = action.split(':', 1) + rank = _verb_rank(action_name, verbs) + if rank is None: + continue + prefix = _normalize(prefix) + resolved_actions = index.resolve(prefix, action_name) + related_actions = { + (service, operation) + for service, operation in resolved_actions + if index.identity_tier(prefix, service, segment_aliases) + is not None + } + if ( + prefix in segment_aliases + and _noun_matches(action_name, resource_segment) + and not related_actions + ): + has_unavailable_exact_lifecycle_operation = True + for service, operation in related_actions: + if ( + _normalize(service) in EXCLUDED_SERVICES + or (service, operation) in FORBIDDEN_OPERATIONS + ): + continue + tier = index.identity_tier(prefix, service, segment_aliases) + candidates.add((tier, rank, service, operation)) + if not candidates: + counters['no_candidates'] += 1 + continue + best_tier = min(candidate[0] for candidate in candidates) + candidates = {c for c in candidates if c[0] == best_tier} + writable_by_lower = { + p.lower(): p for p in set(property_schemas) - read_only + } + scored = [] + for _, rank, service, operation in candidates: + members = index.input_members(service, operation) + mappings = _property_mappings( + members, property_schemas, writable_by_lower, + resource_segment, definitions + ) + precision = len(mappings) / len(members) if members else 0.0 + noun = _noun_matches(operation, resource_segment) + scored.append(( + 0 if noun else 1, + rank, + -len(mappings), + -precision, + service, + operation, + mappings, + noun, + )) + scored.sort() + top = scored[0] + noun, mappings = top[7], top[6] + precision = -top[3] + accepted = (noun and (mappings or not require_mappings)) or ( + len(mappings) >= 2 and precision >= 0.3 + ) + if has_unavailable_exact_lifecycle_operation and not noun: + accepted = False + counters['stale_model_rejected'] += 1 + if not accepted: + counters['rejected'] += 1 + continue + tied = [ + entry + for entry in scored[1:] + if entry[0] == top[0] + and entry[1] == top[1] + and entry[2] == top[2] + and abs(entry[3] - top[3]) < 1e-9 + and (entry[4], entry[5]) != (top[4], top[5]) + ] + if tied: + counters['tied_rejected'] += 1 + continue + adapters[type_name] = { + 'cfn_type': type_name, + 'service': top[4], + 'operation': top[5], + 'phase': role, + 'mappings': [ + {'source': source, 'target': target} + for source, target in mappings + ], + 'ignored_inputs': _ignored_inputs_for_operation( + index.input_members(top[4], top[5]), role, top[4], top[5] + ), + 'noun_matched': noun, + } + counters['verified'] += 1 + return adapters, counters + + +def _enforce_global_uniqueness(adapters): + """One (service, operation) key -> exactly one adapter, or none at all.""" + by_key = defaultdict(list) + for adapter in adapters: + by_key[(adapter['service'].lower(), adapter['operation'])].append(adapter) + kept, dropped = [], [] + for _, group in sorted(by_key.items()): + if len(group) == 1: + kept.append(group[0]) + continue + key = (group[0]['service'].lower(), group[0]['operation']) + preferred_type = COLLISION_PREFERENCES.get(key) + preferred = [ + adapter for adapter in group + if adapter['cfn_type'] == preferred_type + ] + if len(preferred) == 1: + kept.append(preferred[0]) + dropped.extend( + adapter for adapter in group if adapter is not preferred[0] + ) + else: + dropped.extend(group) + return kept, dropped + + +def _verify_curated_updates(compiled_schemas, index): + for adapter in CURATED_UPDATE_ADAPTERS: + constraints = _compiled_constraints(compiled_schemas, adapter['cfn_type']) + if constraints is None: + raise SystemExit( + f"curated update adapter references unknown type {adapter['cfn_type']}" + ) + property_schemas, read_only, primary, definitions = constraints + members = index.input_members(adapter['service'], adapter['operation']) + mapping_sources = set() + for mapping in adapter['mappings']: + if mapping['source'] not in members: + raise SystemExit( + f"curated mapping source {mapping['source']} is not an input of " + f"{adapter['service']}:{adapter['operation']}" + ) + mapping_sources.add(mapping['source']) + target = mapping['target'] + if target not in property_schemas or target in read_only or target in primary: + raise SystemExit( + f"curated mapping target {target} is invalid for {adapter['cfn_type']}" + ) + if not _is_runtime_safe_mapping( + members[mapping['source']], property_schemas[target], + definitions, target + ): + raise SystemExit( + f"curated mapping {mapping['source']} -> {target} is not " + "runtime shape-compatible" + ) + for ignored_name in adapter.get('ignored_inputs', []): + if ignored_name not in members: + raise SystemExit( + f"curated ignored_inputs entry '{ignored_name}' is not an input of " + f"{adapter['service']}:{adapter['operation']}" + ) + if ignored_name in mapping_sources: + raise SystemExit( + f"curated ignored_inputs entry '{ignored_name}' overlaps a mapping " + f"source in {adapter['service']}:{adapter['operation']}" + ) + + +def _compute_coverage(unique_adapters, index, compiled_schemas): + """Compute catalog and state-validation coverage metrics. + + Catalog coverage counts all adapters regardless of phase. + State-validation coverage counts only create/update adapters with at least + one property mapping. + + Denominators: + services — botocore available services (index.service_count) + resources — compiled CloudFormation schema types (len(compiled_schemas)) + commands — total botocore operations (index.operation_count) + writable_properties — unique (type, property) pairs across all compiled + schemas excluding read-only properties + """ + botocore_services = index.service_count + botocore_operations = index.operation_count + compiled_types = len(compiled_schemas) + + writable_pairs = set() + for type_name, schema in compiled_schemas.items(): + if not isinstance(schema, dict): + continue + properties = schema.get('properties') or {} + read_only = set(schema.get('read_only_properties') or []) + for prop in set(properties) - read_only: + writable_pairs.add((type_name, prop)) + + state_adapters = [ + a for a in unique_adapters + if a['phase'] in ('create', 'update') and len(a.get('mappings', [])) > 0 + ] + + covered_writable_pairs = set() + for adapter in state_adapters: + for mapping in adapter.get('mappings', []): + covered_writable_pairs.add((adapter['cfn_type'], mapping['target'])) + + phases = defaultdict(int) + for adapter in unique_adapters: + phases[adapter['phase']] += 1 + + return { + 'catalog_services': { + 'covered': len({a['service'] for a in unique_adapters}), + 'total': botocore_services, + }, + 'catalog_resources': { + 'covered': len({a['cfn_type'] for a in unique_adapters}), + 'total': compiled_types, + }, + 'catalog_commands': { + 'covered': len(unique_adapters), + 'total': botocore_operations, + }, + 'state_services': { + 'covered': len({a['service'] for a in state_adapters}), + 'total': botocore_services, + }, + 'state_resources': { + 'covered': len({a['cfn_type'] for a in state_adapters}), + 'total': compiled_types, + }, + 'state_commands': { + 'covered': len(state_adapters), + 'total': botocore_operations, + }, + 'writable_properties': { + 'covered': len(covered_writable_pairs), + 'total': len(writable_pairs), + }, + 'lifecycle_adapters': dict(phases), + } + + +def _render_derivation(role, counters): + """Explain how provider resource types were matched to API operations.""" + rejection_reasons = ( + ('type_not_compiled', 'Missing from compiled CloudFormation schemas'), + ('no_handler', f'No {role} handler declared in the provider schema'), + ('excluded_service', 'Service excluded from catalog generation'), + ( + 'no_candidates', + 'Handler permissions contained no usable botocore API operation', + ), + ( + 'rejected', + 'Best candidate failed resource-name/property matching safety checks', + ), + ('tied_rejected', 'Multiple API operations tied for best candidate'), + ) + known_outcomes = { + 'verified', + 'stale_model_rejected', + *(outcome for outcome, _ in rejection_reasons), + } + unknown_outcomes = set(counters) - known_outcomes + if unknown_outcomes: + names = ', '.join(sorted(unknown_outcomes)) + raise ValueError(f'no reader-facing description for derivation outcomes: {names}') + + selected = counters.get('verified', 0) + not_selected = sum( + counters.get(outcome, 0) for outcome, _ in rejection_reasons + ) + stale_model_rejected = counters.get('stale_model_rejected', 0) + rejected = counters.get('rejected', 0) + if stale_model_rejected > rejected: + raise ValueError( + 'stale-model rejection count exceeds total candidate rejections' + ) + + title = role.capitalize() + lines = [ + f'{title} API operation matching:', + f' Resource types evaluated from provider schemas: {selected + not_selected:,}', + f' Resource types with one API operation selected: {selected:,}', + f' Resource types without an operation selection: {not_selected:,}', + ] + for outcome, description in rejection_reasons: + count = counters.get(outcome, 0) + if count == 0: + continue + lines.append(f' {description}: {count:,}') + if outcome == 'rejected' and stale_model_rejected: + lines.append( + f' Of those, the exact {role} operation from handler ' + 'permissions was absent from the loaded botocore models: ' + f'{stale_model_rejected:,}' + ) + return lines + + +def _render_fraction(description, entry): + covered = entry['covered'] + total = entry['total'] + percent = (covered / total * 100) if total > 0 else 0.0 + return f' {description}: {covered:,} of {total:,} ({percent:.1f}%)' + + +def _render_coverage(coverage): + """Render coverage metrics with explicit populations and denominators.""" + lines = [ + 'Catalog coverage (all final create, update, and delete adapters):', + _render_fraction( + 'botocore services represented', coverage['catalog_services'] + ), + _render_fraction( + 'Compiled CloudFormation resource types represented', + coverage['catalog_resources'], + ), + _render_fraction( + 'botocore API operations represented', coverage['catalog_commands'] + ), + '', + ( + 'State validation coverage (create/update adapters with at least ' + 'one writable-property mapping):' + ), + _render_fraction( + 'botocore services with state validation', coverage['state_services'] + ), + _render_fraction( + 'Compiled CloudFormation resource types with state validation', + coverage['state_resources'], + ), + _render_fraction( + 'botocore API operations used for state validation', + coverage['state_commands'], + ), + _render_fraction( + 'Writable CloudFormation properties mapped for state validation', + coverage['writable_properties'], + ), + '', + 'Final adapters by lifecycle phase:', + ] + lifecycle = coverage.get('lifecycle_adapters', {}) + for phase in ('create', 'update', 'delete'): + lines.append(f' {phase.capitalize()} adapters: {lifecycle.get(phase, 0):,}') + for phase in sorted(set(lifecycle) - {'create', 'update', 'delete'}): + lines.append(f' {phase.capitalize()} adapters: {lifecycle[phase]:,}') + return lines + + +def _render_generation_report( + create_counters, + delete_counters, + dropped_count, + coverage, + adapter_count, + output_path, +): + """Render the complete catalog generation report.""" + lines = [ + 'AWS API catalog generation summary', + ( + 'An adapter links one CloudFormation resource type and lifecycle ' + 'action to one botocore API operation.' + ), + '', + ] + lines.extend(_render_derivation('create', create_counters)) + lines.append('') + lines.extend(_render_derivation('delete', delete_counters)) + lines.extend([ + '', + 'API operation uniqueness check:', + ( + ' Adapters removed so each botocore API operation appears only ' + f'once: {dropped_count:,}' + ), + '', + ]) + lines.extend(_render_coverage(coverage)) + lines.extend([ + '', + 'Catalog output:', + f' Adapters written: {adapter_count:,}', + f' File: {output_path}', + ]) + return lines + + +def _run_unit_tests(): + test_file = Path(__file__).with_name('test_generate_aws_api_catalog.py') + completed = subprocess.run( + [sys.executable, '-m', 'unittest', '-v', test_file.stem], + cwd=test_file.parent, + check=False, + ) + if completed.returncode != 0: + raise SystemExit( + 'catalog generator unit tests failed with exit code ' + f'{completed.returncode}' + ) + + +def main(): + args = _parse_args() + _run_unit_tests() + if not args.botocore_root.is_dir(): + raise SystemExit( + f'botocore root directory not found: {args.botocore_root}' + ) + sys.path.insert(0, str(args.botocore_root.resolve())) + try: + botocore_module = importlib.import_module('botocore') + except ModuleNotFoundError as error: + raise SystemExit( + f'cannot import botocore from {args.botocore_root}: {error}' + ) from error + + compiled_schemas = json.loads(args.compiled_schemas.read_text()) + provider_schemas = _load_provider_schemas(args.provider_schemas) + index = BotocoreIndex() + + creates, create_counters = _derive_role( + 'create', CREATE_VERBS, provider_schemas, compiled_schemas, index, True + ) + deletes, delete_counters = _derive_role( + 'delete', DELETE_VERBS, provider_schemas, compiled_schemas, index, False + ) + _verify_curated_updates(compiled_schemas, index) + + all_adapters = ( + list(creates.values()) + + list(deletes.values()) + + [dict(adapter) for adapter in CURATED_UPDATE_ADAPTERS] + ) + unique_adapters, dropped = _enforce_global_uniqueness(all_adapters) + + for adapter in unique_adapters: + key = (adapter['service'], adapter['operation']) + if key in FORBIDDEN_OPERATIONS: + raise SystemExit(f'forbidden operation selected: {key} for {adapter["cfn_type"]}') + + final_creates = { + a['cfn_type']: a for a in unique_adapters if a['phase'] == 'create' + } + for type_name, expected in sorted(EXPECTED_PAIRS.items()): + actual = final_creates.get(type_name) + if actual is None: + raise SystemExit(f'expected pair missing after uniqueness: {type_name}') + if (actual['service'], actual['operation']) != expected: + raise SystemExit( + f'expected pair mismatch for {type_name}: ' + f"got {(actual['service'], actual['operation'])}, want {expected}" + ) + + for adapter in unique_adapters: + adapter.pop('noun_matched', None) + if not adapter.get('ignored_inputs'): + adapter.pop('ignored_inputs', None) + unique_adapters.sort(key=lambda a: (a['cfn_type'], a['phase'])) + document = { + 'format_version': FORMAT_VERSION, + 'source': { + 'provider_schemas_sha256': _source_sha256( + args.provider_schemas + ), + 'compiled_schemas_sha256': _source_sha256( + args.compiled_schemas + ), + 'botocore_version': botocore_module.__version__, + 'botocore_service_count': index.service_count, + 'provider_type_count': len(provider_schemas), + 'compiled_type_count': len(compiled_schemas), + }, + 'adapters': unique_adapters, + } + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(document, indent=1, sort_keys=True) + '\n') + + coverage = _compute_coverage(unique_adapters, index, compiled_schemas) + for line in _render_generation_report( + create_counters, + delete_counters, + len(dropped), + coverage, + len(unique_adapters), + args.output, + ): + print(line) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/src/data-source/scripts/test_generate_aws_api_catalog.py b/src/data-source/scripts/test_generate_aws_api_catalog.py new file mode 100644 index 00000000..e56aaa56 --- /dev/null +++ b/src/data-source/scripts/test_generate_aws_api_catalog.py @@ -0,0 +1,440 @@ +#!/usr/bin/env python3 +import json +import tempfile +import unittest +from pathlib import Path + +import generate_aws_api_catalog as catalog + + +class Shape: + def __init__(self, type_name, *, member=None, value=None, metadata=None, + serialization=None): + self.type_name = type_name + self.member = member + self.value = value + self.metadata = metadata or {} + self.serialization = serialization or {} + + +class CatalogGeneratorTest(unittest.TestCase): + def test_unreviewed_collision_is_dropped(self): + adapters = [ + { + "service": "quicksight", + "operation": "CreateTopic", + "cfn_type": "AWS::QuickSight::Topic", + }, + { + "service": "quicksight", + "operation": "CreateTopic", + "cfn_type": "AWS::QuickSight::TopicV2", + }, + ] + + kept, dropped = catalog._enforce_global_uniqueness(adapters) + + self.assertEqual([], kept) + self.assertEqual(2, len(dropped)) + + def test_reviewed_collision_keeps_only_preferred_type(self): + adapters = [ + { + "service": "dynamodb", + "operation": "CreateTable", + "cfn_type": "AWS::DynamoDB::GlobalTable", + }, + { + "service": "dynamodb", + "operation": "CreateTable", + "cfn_type": "AWS::DynamoDB::Table", + }, + ] + + kept, dropped = catalog._enforce_global_uniqueness(adapters) + + self.assertEqual(["AWS::DynamoDB::Table"], [entry["cfn_type"] for entry in kept]) + self.assertEqual(["AWS::DynamoDB::GlobalTable"], [entry["cfn_type"] for entry in dropped]) + + def test_runtime_safe_mapping_accepts_only_serializable_shapes(self): + definitions = { + "Tag": { + "type": "object", + "properties": {"Key": {"type": "string"}, "Value": {"type": "string"}}, + } + } + tags = {"type": "array", "items": {"ref_name": "Tag"}} + strings = {"type": "array", "items": {"type": "string"}} + + self.assertTrue( + catalog._is_runtime_safe_mapping(Shape("string"), {"type": "string"}, {}, "Name") + ) + self.assertTrue( + catalog._is_runtime_safe_mapping( + Shape("list", member=Shape("string")), strings, {}, "Names" + ) + ) + self.assertTrue( + catalog._is_runtime_safe_mapping( + Shape("map", value=Shape("string")), tags, definitions, "Tags" + ) + ) + self.assertFalse( + catalog._is_runtime_safe_mapping(Shape("structure"), {"type": "object"}, {}, "Config") + ) + self.assertFalse( + catalog._is_runtime_safe_mapping( + Shape("list", member=Shape("structure")), + {"type": "array", "items": {"type": "object"}}, + {}, + "Configs", + ) + ) + + def test_provider_schema_directory_is_loaded_deterministically(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + (root / "b.json").write_text(json.dumps({"typeName": "AWS::Test::B"})) + (root / "a.json").write_text(json.dumps({"typeName": "AWS::Test::A"})) + (root / "ignored.json").write_text(json.dumps({"notTypeName": "AWS::Test::Ignored"})) + + schemas = catalog._load_provider_schemas(root) + first_hash = catalog._source_sha256(root) + second_hash = catalog._source_sha256(root) + + self.assertEqual(["AWS::Test::A", "AWS::Test::B"], sorted(schemas)) + self.assertEqual(first_hash, second_hash) + + +class IgnoredInputsTest(unittest.TestCase): + """Tests for _ignored_inputs_for_operation.""" + + def test_curated_name_is_ignored(self): + members = { + 'ClientToken': Shape('string'), + 'BucketName': Shape('string'), + } + result = catalog._ignored_inputs_for_operation(members, 'create', 's3', 'CreateBucket') + self.assertEqual(result, ['ClientToken']) + + def test_dry_run_is_ignored(self): + members = { + 'DryRun': Shape('boolean'), + 'InstanceId': Shape('string'), + } + result = catalog._ignored_inputs_for_operation(members, 'create', 'ec2', 'RunInstances') + self.assertEqual(result, ['DryRun']) + + def test_idempotency_token_metadata_is_detected(self): + members = { + 'Token': Shape('string', metadata={'idempotencyToken': True}), + 'Name': Shape('string'), + } + result = catalog._ignored_inputs_for_operation(members, 'create', 'test', 'CreateThing') + self.assertEqual(result, ['Token']) + + def test_idempotency_token_serialization_is_detected(self): + members = { + 'RequestId': Shape('string', serialization={'idempotencyToken': True}), + 'Data': Shape('string'), + } + result = catalog._ignored_inputs_for_operation(members, 'create', 'test', 'CreateThing') + self.assertEqual(result, ['RequestId']) + + def test_update_phase_does_not_add_curated_identifiers(self): + """_ignored_inputs_for_operation derives only request-control fields.""" + members = { + 'FunctionName': Shape('string'), + 'MemorySize': Shape('integer'), + } + result = catalog._ignored_inputs_for_operation( + members, 'update', 'lambda', 'UpdateFunctionConfiguration' + ) + self.assertNotIn('FunctionName', result) + + def test_no_heuristic_detection(self): + """Members not in the curated set or metadata are never ignored.""" + members = { + 'TokenValue': Shape('string'), + 'RequestId': Shape('string'), + 'Nonce': Shape('string'), + } + result = catalog._ignored_inputs_for_operation(members, 'create', 'test', 'CreateThing') + self.assertEqual(result, []) + + def test_returns_sorted(self): + members = { + 'DryRun': Shape('boolean'), + 'ClientToken': Shape('string'), + 'BucketName': Shape('string'), + } + result = catalog._ignored_inputs_for_operation(members, 'create', 's3', 'CreateBucket') + self.assertEqual(result, sorted(result)) + + +class CoverageMetricsTest(unittest.TestCase): + """Tests for _compute_coverage and _render_coverage with synthetic data.""" + + def _synthetic_coverage(self, adapters, botocore_operations=100, + botocore_services=10, compiled_schemas=None): + """Build a synthetic coverage computation.""" + if compiled_schemas is None: + compiled_schemas = { + 'AWS::Test::Type': { + 'properties': {'Name': {}, 'Arn': {}, 'Id': {}}, + 'read_only_properties': ['Arn'], + }, + } + + class FakeIndex: + def __init__(self, services, operations): + self.service_count = services + self.operation_count = operations + + index = FakeIndex(botocore_services, botocore_operations) + return catalog._compute_coverage(adapters, index, compiled_schemas) + + def test_zero_adapters_yields_zero_coverage(self): + coverage = self._synthetic_coverage([]) + self.assertEqual(coverage['catalog_services']['covered'], 0) + self.assertEqual(coverage['catalog_resources']['covered'], 0) + self.assertEqual(coverage['writable_properties']['covered'], 0) + self.assertEqual(coverage['catalog_commands']['covered'], 0) + self.assertEqual(coverage['state_commands']['covered'], 0) + + def test_single_create_adapter_coverage(self): + adapters = [{ + 'service': 'test', + 'operation': 'CreateThing', + 'cfn_type': 'AWS::Test::Type', + 'phase': 'create', + 'mappings': [{'source': 'Name', 'target': 'Name'}], + }] + coverage = self._synthetic_coverage(adapters) + self.assertEqual(coverage['catalog_services']['covered'], 1) + self.assertEqual(coverage['catalog_services']['total'], 10) + self.assertEqual(coverage['catalog_resources']['covered'], 1) + self.assertEqual(coverage['catalog_commands']['covered'], 1) + self.assertEqual(coverage['catalog_commands']['total'], 100) + self.assertEqual(coverage['state_commands']['covered'], 1) + self.assertEqual(coverage['state_services']['covered'], 1) + self.assertEqual(coverage['state_resources']['covered'], 1) + self.assertEqual(coverage['writable_properties']['covered'], 1) + # Total writable is 2 (Name + Id; Arn is read-only) + self.assertEqual(coverage['writable_properties']['total'], 2) + + def test_delete_adapter_does_not_count_as_state_validation(self): + adapters = [{ + 'service': 'test', + 'operation': 'DeleteThing', + 'cfn_type': 'AWS::Test::Type', + 'phase': 'delete', + 'mappings': [], + }] + coverage = self._synthetic_coverage(adapters) + self.assertEqual(coverage['state_commands']['covered'], 0) + self.assertEqual(coverage['catalog_commands']['covered'], 1) + self.assertEqual(coverage['lifecycle_adapters'], {'delete': 1}) + + def test_writable_properties_are_deduplicated_across_adapters(self): + """Two adapters mapping to the same (cfn_type, target) count once.""" + adapters = [ + { + 'service': 'test', + 'operation': 'Create', + 'cfn_type': 'AWS::Test::Type', + 'phase': 'create', + 'mappings': [{'source': 'Name', 'target': 'Name'}], + }, + { + 'service': 'test', + 'operation': 'Update', + 'cfn_type': 'AWS::Test::Type', + 'phase': 'update', + 'mappings': [{'source': 'Name', 'target': 'Name'}], + }, + ] + coverage = self._synthetic_coverage(adapters) + self.assertEqual(coverage['writable_properties']['covered'], 1) + + def test_render_derivation_explains_outcomes_and_subset(self): + counters = { + 'verified': 1305, + 'rejected': 113, + 'no_candidates': 118, + 'no_handler': 175, + 'tied_rejected': 3, + 'excluded_service': 15, + 'stale_model_rejected': 1, + } + + lines = catalog._render_derivation('create', counters) + + self.assertEqual([ + 'Create API operation matching:', + ' Resource types evaluated from provider schemas: 1,729', + ' Resource types with one API operation selected: 1,305', + ' Resource types without an operation selection: 424', + ' No create handler declared in the provider schema: 175', + ' Service excluded from catalog generation: 15', + ( + ' Handler permissions contained no usable botocore API ' + 'operation: 118' + ), + ( + ' Best candidate failed resource-name/property matching ' + 'safety checks: 113' + ), + ( + ' Of those, the exact create operation from handler ' + 'permissions was absent from the loaded botocore models: 1' + ), + ' Multiple API operations tied for best candidate: 3', + ], lines) + + def test_render_derivation_rejects_unexplained_outcome(self): + with self.assertRaisesRegex( + ValueError, 'no reader-facing description.*new_outcome' + ): + catalog._render_derivation( + 'create', {'verified': 1, 'new_outcome': 1} + ) + + def test_render_coverage_formats_percentages(self): + coverage = { + 'catalog_services': {'covered': 3, 'total': 10}, + 'catalog_resources': {'covered': 5, 'total': 20}, + 'catalog_commands': {'covered': 7, 'total': 50}, + 'state_services': {'covered': 2, 'total': 10}, + 'state_resources': {'covered': 4, 'total': 20}, + 'state_commands': {'covered': 4, 'total': 50}, + 'writable_properties': {'covered': 15, 'total': 100}, + 'lifecycle_adapters': {'create': 4, 'delete': 3}, + } + + lines = catalog._render_coverage(coverage) + + self.assertEqual([ + 'Catalog coverage (all final create, update, and delete adapters):', + ' botocore services represented: 3 of 10 (30.0%)', + ( + ' Compiled CloudFormation resource types represented: ' + '5 of 20 (25.0%)' + ), + ' botocore API operations represented: 7 of 50 (14.0%)', + '', + ( + 'State validation coverage (create/update adapters with at ' + 'least one writable-property mapping):' + ), + ' botocore services with state validation: 2 of 10 (20.0%)', + ( + ' Compiled CloudFormation resource types with state ' + 'validation: 4 of 20 (20.0%)' + ), + ( + ' botocore API operations used for state validation: ' + '4 of 50 (8.0%)' + ), + ( + ' Writable CloudFormation properties mapped for state ' + 'validation: 15 of 100 (15.0%)' + ), + '', + 'Final adapters by lifecycle phase:', + ' Create adapters: 4', + ' Update adapters: 0', + ' Delete adapters: 3', + ], lines) + + def test_generation_report_explains_uniqueness_and_output(self): + coverage = { + 'catalog_services': {'covered': 1, 'total': 1}, + 'catalog_resources': {'covered': 1, 'total': 1}, + 'catalog_commands': {'covered': 2, 'total': 2}, + 'state_services': {'covered': 1, 'total': 1}, + 'state_resources': {'covered': 1, 'total': 1}, + 'state_commands': {'covered': 1, 'total': 2}, + 'writable_properties': {'covered': 1, 'total': 2}, + 'lifecycle_adapters': {'create': 1, 'delete': 1}, + } + + lines = catalog._render_generation_report( + {'verified': 1}, + {'verified': 1}, + 2, + coverage, + 2, + Path('/tmp/catalog.json'), + ) + + self.assertEqual('AWS API catalog generation summary', lines[0]) + self.assertIn( + 'An adapter links one CloudFormation resource type and lifecycle ' + 'action to one botocore API operation.', + lines, + ) + self.assertIn('API operation uniqueness check:', lines) + self.assertIn( + ' Adapters removed so each botocore API operation appears only ' + 'once: 2', + lines, + ) + self.assertEqual([ + 'Catalog output:', + ' Adapters written: 2', + ' File: /tmp/catalog.json', + ], lines[-3:]) + + def test_zero_total_does_not_divide_by_zero(self): + coverage = { + 'catalog_services': {'covered': 0, 'total': 0}, + 'catalog_resources': {'covered': 0, 'total': 0}, + 'catalog_commands': {'covered': 0, 'total': 0}, + 'state_services': {'covered': 0, 'total': 0}, + 'state_resources': {'covered': 0, 'total': 0}, + 'state_commands': {'covered': 0, 'total': 0}, + 'writable_properties': {'covered': 0, 'total': 0}, + 'lifecycle_adapters': {}, + } + + lines = catalog._render_coverage(coverage) + + percentage_lines = [line for line in lines if line.endswith('%)')] + self.assertEqual(7, len(percentage_lines)) + self.assertTrue(all('(0.0%)' in line for line in percentage_lines)) + + def test_exact_percentage_calculation(self): + adapters = [ + { + 'service': 'svc0', + 'operation': 'Create', + 'cfn_type': 'AWS::A::B', + 'phase': 'create', + 'mappings': [{'source': 'X', 'target': 'Y'}], + }, + { + 'service': 'svc1', + 'operation': 'Update', + 'cfn_type': 'AWS::A::B', + 'phase': 'update', + 'mappings': [{'source': 'Z', 'target': 'W'}], + }, + ] + # 2 services out of 4, 2 commands out of 8 + compiled = {'AWS::A::B': {'properties': {'Y': {}, 'W': {}}, 'read_only_properties': []}} + coverage = self._synthetic_coverage( + adapters, botocore_operations=8, botocore_services=4, + compiled_schemas=compiled, + ) + self.assertEqual(coverage['catalog_services']['covered'], 2) + self.assertEqual(coverage['catalog_services']['total'], 4) + self.assertEqual(coverage['catalog_commands']['covered'], 2) + self.assertEqual(coverage['catalog_commands']['total'], 8) + self.assertEqual(coverage['state_commands']['covered'], 2) + self.assertEqual(coverage['writable_properties']['covered'], 2) + self.assertEqual(coverage['writable_properties']['total'], 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/src/data-source/src/generate.rs b/src/data-source/src/generate.rs index 0ad0ebb5..76e2d18f 100644 --- a/src/data-source/src/generate.rs +++ b/src/data-source/src/generate.rs @@ -9,7 +9,7 @@ fn main() -> anyhow::Result<()> { eprintln!( "Usage: cargo run -p data-source --features maintenance --example generate\n\n\ Generates all outputs from existing upstream data.\n\ - To refresh upstream data first, run `cargo run -p data-source --features maintenance --example sync -- --cfn-lint-root `." + To refresh upstream data first, run `cargo run -p data-source --features maintenance --example sync -- --cfn-lint-root --aws-cli-root `." ); return Ok(()); } diff --git a/src/data-source/src/lib.rs b/src/data-source/src/lib.rs index f035a9ca..6381ca1f 100644 --- a/src/data-source/src/lib.rs +++ b/src/data-source/src/lib.rs @@ -135,6 +135,108 @@ pub fn sync_upstream(upstream_dir: &Path, rule_source_root: &str) -> anyhow::Res Ok(()) } +#[cfg(feature = "maintenance")] +const AWS_API_OPERATION_CATALOG_FORMAT_VERSION: u64 = 1; + +#[cfg(feature = "maintenance")] +#[derive(serde::Deserialize)] +struct AwsApiOperationCatalog { + format_version: u64, + adapters: Vec, +} + +/// Generate the AWS API operation catalog from synced provider schemas and compiled schemas. +#[cfg(feature = "maintenance")] +pub fn generate_aws_api_catalog(upstream_dir: &Path, generated_dir: &Path, aws_cli_root: &Path) -> anyhow::Result<()> { + let botocore_root = aws_cli_root.join("awscli"); + let botocore_package = botocore_root.join("botocore").join("__init__.py"); + let provider_schemas = upstream_dir.join("schemas"); + let compiled_schemas = generated_dir.join("schema-validator").join("compiled_schemas.json"); + let catalog_path = generated_dir.join("data").join("aws_api_operation_catalog.json"); + let script_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("scripts").join("generate_aws_api_catalog.py"); + + anyhow::ensure!(script_path.is_file(), "AWS API catalog generator not found at {}", script_path.display()); + anyhow::ensure!(aws_cli_root.is_dir(), "AWS CLI checkout not found at {}", aws_cli_root.display()); + anyhow::ensure!( + botocore_package.is_file(), + "AWS CLI checkout does not contain botocore at {}", + botocore_package.display() + ); + anyhow::ensure!( + provider_schemas.is_dir(), + "provider schemas directory not found at {}", + provider_schemas.display() + ); + anyhow::ensure!(compiled_schemas.is_file(), "compiled schemas not found at {}", compiled_schemas.display()); + + info!("Generating AWS API operation catalog via {}", script_path.display()); + let status = std::process::Command::new("python3") + .arg(&script_path) + .arg("--botocore-root") + .arg(&botocore_root) + .arg("--provider-schemas") + .arg(&provider_schemas) + .arg("--compiled-schemas") + .arg(&compiled_schemas) + .arg("--output") + .arg(&catalog_path) + .status() + .map_err(|error| anyhow::anyhow!("failed to start AWS API catalog generator: {error}"))?; + anyhow::ensure!(status.success(), "AWS API catalog generator failed with {status}"); + + let catalog_bytes = fs::read(&catalog_path) + .map_err(|error| anyhow::anyhow!("failed to read generated catalog {}: {error}", catalog_path.display()))?; + let adapter_count = validate_aws_api_catalog(&catalog_bytes)?; + info!("Generated AWS API operation catalog with {adapter_count} adapters at {}", catalog_path.display()); + Ok(()) +} + +#[cfg(feature = "maintenance")] +fn validate_aws_api_catalog(catalog_bytes: &[u8]) -> anyhow::Result { + let catalog: AwsApiOperationCatalog = serde_json::from_slice(catalog_bytes) + .map_err(|error| anyhow::anyhow!("generated AWS API operation catalog is invalid JSON: {error}"))?; + anyhow::ensure!( + catalog.format_version == AWS_API_OPERATION_CATALOG_FORMAT_VERSION, + "generated AWS API operation catalog has format version {}, expected {}", + catalog.format_version, + AWS_API_OPERATION_CATALOG_FORMAT_VERSION + ); + anyhow::ensure!(!catalog.adapters.is_empty(), "generated AWS API operation catalog contains no adapters"); + Ok(catalog.adapters.len()) +} + +#[cfg(all(test, feature = "maintenance"))] +mod aws_api_catalog_tests { + use super::*; + + #[test] + fn current_catalog_format_with_adapters_is_valid() { + let catalog = br#"{"format_version":1,"adapters":[{}]}"#; + + let adapter_count = validate_aws_api_catalog(catalog).expect("catalog should be valid"); + + assert_eq!(1, adapter_count); + } + + #[test] + fn unsupported_catalog_format_is_rejected() { + let catalog = br#"{"format_version":2,"adapters":[{}]}"#; + + let error = validate_aws_api_catalog(catalog).expect_err("unsupported format must fail"); + + assert!(error.to_string().contains("format version 2, expected 1")); + } + + #[test] + fn catalog_without_adapters_is_rejected() { + let catalog = br#"{"format_version":1,"adapters":[]}"#; + + let error = validate_aws_api_catalog(catalog).expect_err("empty adapters must fail"); + + assert!(error.to_string().contains("contains no adapters")); + } +} + #[cfg(feature = "maintenance")] pub fn generate_all(upstream_dir: &Path, generated_dir: &Path, handwritten_dir: &Path) -> anyhow::Result<()> { info!("=== Generate phase ==="); diff --git a/src/data-source/src/sync.rs b/src/data-source/src/sync.rs index bc197357..e71ad081 100644 --- a/src/data-source/src/sync.rs +++ b/src/data-source/src/sync.rs @@ -1,5 +1,5 @@ use anyhow::Context; -use data_source::{generate_all, sync_upstream}; +use data_source::{generate_all, generate_aws_api_catalog, sync_upstream}; use log::{error, info}; use std::env; use std::fs; @@ -12,6 +12,7 @@ fn main() -> anyhow::Result<()> { let args: Vec = env::args().collect(); let mut rule_source_root: Option = None; + let mut aws_cli_root: Option = None; let mut i = 1; while i < args.len() { match args[i].as_str() { @@ -23,6 +24,14 @@ fn main() -> anyhow::Result<()> { } rule_source_root = Some(args[i].clone()); } + "--aws-cli-root" => { + i += 1; + if i >= args.len() { + error!("--aws-cli-root requires a path argument"); + process::exit(1); + } + aws_cli_root = Some(args[i].clone()); + } "--help" | "-h" => { print_usage(); return Ok(()); @@ -37,6 +46,7 @@ fn main() -> anyhow::Result<()> { } let rule_source_root = rule_source_root.ok_or_else(|| anyhow::anyhow!("--cfn-lint-root is required"))?; + let aws_cli_root = aws_cli_root.ok_or_else(|| anyhow::anyhow!("--aws-cli-root is required"))?; let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let upstream_dir = manifest.join("upstream"); let generated_dir = manifest.join("generated"); @@ -48,6 +58,7 @@ fn main() -> anyhow::Result<()> { sync_upstream(&upstream_dir, &rule_source_root)?; generate_all(&upstream_dir, &generated_dir, &handwritten_dir)?; + generate_aws_api_catalog(&upstream_dir, &generated_dir, Path::new(&aws_cli_root))?; info!("Sync and generation complete"); Ok(()) @@ -61,12 +72,14 @@ fn clear_cache_directory(cache_directory: &Path) -> anyhow::Result<()> { fn print_usage() { eprintln!( - "Usage: cargo run -p data-source --features maintenance --example sync -- --cfn-lint-root + "Usage: cargo run -p data-source --features maintenance --example sync -- --cfn-lint-root --aws-cli-root -Refreshes all upstream sources, records their versions, and generates every output. +Refreshes all upstream sources, records their versions, generates every output, +and rebuilds the AWS API operation catalog. Options: --cfn-lint-root Path to cfn-lint repo (required) + --aws-cli-root Path to AWS CLI checkout (required) -h, --help Show this help" ); } diff --git a/src/data-source/uniffi.toml b/src/data-source/uniffi.toml index f7802e9c..f0c156ff 100644 --- a/src/data-source/uniffi.toml +++ b/src/data-source/uniffi.toml @@ -1,3 +1,4 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate.datasource" generate_immutable_records = true +disable_java_cleaner = true diff --git a/src/diagnostics/uniffi.toml b/src/diagnostics/uniffi.toml index 00a38af0..db9d160e 100644 --- a/src/diagnostics/uniffi.toml +++ b/src/diagnostics/uniffi.toml @@ -1,6 +1,7 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate.diagnostics" generate_immutable_records = true +disable_java_cleaner = true [bindings.kotlin.external_packages] rules = "software.amazon.cloudformation.validate.rules" diff --git a/src/rules/uniffi.toml b/src/rules/uniffi.toml index e1357541..96a21b0b 100644 --- a/src/rules/uniffi.toml +++ b/src/rules/uniffi.toml @@ -1,3 +1,4 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate.rules" generate_immutable_records = true +disable_java_cleaner = true diff --git a/src/schema-validator/src/lib.rs b/src/schema-validator/src/lib.rs index 62c0ac80..1bbd68f4 100644 --- a/src/schema-validator/src/lib.rs +++ b/src/schema-validator/src/lib.rs @@ -2,6 +2,7 @@ pub mod catalog; pub(crate) mod compiled; pub(crate) mod convert; pub mod overlay; +pub mod resource_schema; pub mod store; pub mod validate; @@ -11,6 +12,7 @@ uniffi::setup_scaffolding!(); pub use catalog::OverlayCatalog; pub use data_source::{AdditionalSchemaSource, SchemaSourceError}; pub use overlay::{MAX_OVERLAY_DEPTH, SchemaOverlayError}; +pub use resource_schema::{PropertyValueType, ResourceSchemaMetadata}; pub use store::{CompiledSchemaStore, OverlayOutcome}; /// Eagerly decompress all embedded data LazyLocks. Intended to be called once at @@ -278,6 +280,23 @@ impl SchemaValidator { self.store.len() } + /// Returns the schema fields needed to map request parameters to one + /// CloudFormation resource type, including configured schema overlays. + pub fn resource_schema_metadata(&self, type_name: &str) -> Option { + self.store.get(type_name).map(ResourceSchemaMetadata::from_compiled) + } + + /// Whether this validator has a bundled or caller-provided schema for a + /// CloudFormation resource type. + pub fn has_resource_type(&self, type_name: &str) -> bool { + self.store.get(type_name).is_some() + } + + /// Iterates every bundled and caller-provided CloudFormation resource type. + pub fn resource_type_names(&self) -> impl Iterator { + self.store.type_names() + } + pub fn list_rules(&self) -> Vec { // Every rule ID the schema-validator can emit (see src/validate.rs). const SCHEMA_RULE_IDS: &[&str] = &[ diff --git a/src/schema-validator/src/resource_schema.rs b/src/schema-validator/src/resource_schema.rs new file mode 100644 index 00000000..9cae198a --- /dev/null +++ b/src/schema-validator/src/resource_schema.rs @@ -0,0 +1,174 @@ +use crate::compiled::{CompiledSchema, PropSchema}; +use std::collections::{BTreeMap, BTreeSet, HashMap}; + +/// JSON value categories accepted by a CloudFormation resource property. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum PropertyValueType { + Any, + Array, + Object, + Boolean, + Integer, + Number, + String, +} + +/// Schema information needed to map an AWS API request into one resource. +/// +/// This is intentionally narrower than the validator's compiled schema model: +/// callers can select and type-check resource properties without depending on +/// validation implementation details. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResourceSchemaMetadata { + pub type_name: String, + pub property_types: BTreeMap>, + pub required_properties: BTreeSet, + pub read_only_properties: BTreeSet, + pub primary_identifier_properties: BTreeSet, +} + +impl ResourceSchemaMetadata { + pub(crate) fn from_compiled(schema: &CompiledSchema) -> Self { + let property_types = schema + .properties + .iter() + .map(|(name, property)| (name.clone(), accepted_value_types(property, &schema.definitions))) + .collect(); + Self { + type_name: schema.type_name.clone(), + property_types, + required_properties: schema.required.iter().cloned().collect(), + read_only_properties: schema.read_only_properties.iter().cloned().collect(), + primary_identifier_properties: schema.primary_identifier.iter().cloned().collect(), + } + } +} + +const MAX_COMPOSITION_DEPTH: usize = 64; + +fn accepted_value_types( + property: &PropSchema, + definitions: &HashMap, +) -> BTreeSet { + let mut accepted = BTreeSet::new(); + collect_value_types(property, definitions, 0, &mut accepted); + accepted.remove(&PropertyValueType::Any); + if accepted.is_empty() { + accepted.insert(PropertyValueType::Any); + } + accepted +} + +fn collect_value_types( + property: &PropSchema, + definitions: &HashMap, + depth: usize, + accepted: &mut BTreeSet, +) { + if depth >= MAX_COMPOSITION_DEPTH { + accepted.insert(PropertyValueType::Any); + return; + } + + let property = property.resolve(definitions); + if let Some(property_type) = &property.prop_type { + for name in property_type.names() { + match name { + "array" => { + accepted.insert(PropertyValueType::Array); + } + "object" => { + accepted.insert(PropertyValueType::Object); + } + "boolean" => { + accepted.insert(PropertyValueType::Boolean); + } + "integer" => { + accepted.insert(PropertyValueType::Integer); + } + "number" => { + accepted.insert(PropertyValueType::Number); + } + "string" => { + accepted.insert(PropertyValueType::String); + } + "null" => {} + _ => { + accepted.insert(PropertyValueType::Any); + } + } + } + } + if property.items.is_some() || property.min_items.is_some() || property.max_items.is_some() { + accepted.insert(PropertyValueType::Array); + } + if !property.properties.is_empty() + || !property.pattern_properties.is_empty() + || property.additional_properties.is_some() + || property.min_properties.is_some() + || property.max_properties.is_some() + { + accepted.insert(PropertyValueType::Object); + } + for alternative in property.all_of.iter().chain(property.any_of.iter()).chain(property.one_of.iter()) { + collect_value_types(alternative, definitions, depth + 1, accepted); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::compiled::PropType; + + #[test] + fn metadata_resolves_referenced_property_types() { + let mut definitions = HashMap::new(); + definitions.insert( + "Configuration".to_string(), + PropSchema { prop_type: Some(PropType::Single("object".into())), ..Default::default() }, + ); + let schema = CompiledSchema { + type_name: "AWS::Test::Thing".into(), + properties: HashMap::from([( + "Configuration".into(), + PropSchema { ref_name: Some("Configuration".into()), ..Default::default() }, + )]), + definitions, + required: vec!["Configuration".into()], + read_only_properties: vec!["Arn".into()], + primary_identifier: vec!["Name".into()], + ..Default::default() + }; + + let metadata = ResourceSchemaMetadata::from_compiled(&schema); + + assert_eq!(metadata.property_types["Configuration"], BTreeSet::from([PropertyValueType::Object])); + assert!(metadata.required_properties.contains("Configuration")); + assert!(metadata.read_only_properties.contains("Arn")); + assert!(metadata.primary_identifier_properties.contains("Name")); + } + + #[test] + fn metadata_unions_composed_property_types() { + let property = PropSchema { + one_of: vec![ + PropSchema { prop_type: Some(PropType::Single("string".into())), ..Default::default() }, + PropSchema { prop_type: Some(PropType::Single("integer".into())), ..Default::default() }, + ], + ..Default::default() + }; + + assert_eq!( + accepted_value_types(&property, &HashMap::new()), + BTreeSet::from([PropertyValueType::Integer, PropertyValueType::String]) + ); + } + + #[test] + fn metadata_uses_any_when_no_value_type_is_known() { + assert_eq!( + accepted_value_types(&PropSchema::default(), &HashMap::new()), + BTreeSet::from([PropertyValueType::Any]) + ); + } +} diff --git a/src/schema-validator/src/store.rs b/src/schema-validator/src/store.rs index 0c353c6a..d6af32ba 100644 --- a/src/schema-validator/src/store.rs +++ b/src/schema-validator/src/store.rs @@ -98,6 +98,10 @@ impl CompiledSchemaStore { self.schemas.get(type_name) } + pub fn type_names(&self) -> impl Iterator { + self.schemas.keys().map(String::as_str) + } + /// Merge an overlay CloudFormation resource provider schema (raw registry /// JSON) into the store under `type_name`. /// diff --git a/src/schema-validator/uniffi.toml b/src/schema-validator/uniffi.toml index cee50680..b1d7c48d 100644 --- a/src/schema-validator/uniffi.toml +++ b/src/schema-validator/uniffi.toml @@ -1,6 +1,7 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate.schemavalidator" generate_immutable_records = true +disable_java_cleaner = true [bindings.kotlin.external_packages] data_source = "software.amazon.cloudformation.validate.datasource" diff --git a/src/template-model/uniffi.toml b/src/template-model/uniffi.toml index 297e2738..2c7a4983 100644 --- a/src/template-model/uniffi.toml +++ b/src/template-model/uniffi.toml @@ -1,6 +1,7 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate.templatemodel" generate_immutable_records = true +disable_java_cleaner = true [bindings.kotlin.external_packages] diagnostics = "software.amazon.cloudformation.validate.diagnostics" diff --git a/src/validation-engine/API.md b/src/validation-engine/API.md index 5c2db248..a9911694 100644 --- a/src/validation-engine/API.md +++ b/src/validation-engine/API.md @@ -33,6 +33,81 @@ for d in &report.diagnostics { On parse failure, `validate_bytes_with_path` returns `Ok(report)` with a synthetic `F1101` diagnostic and `status=Error` rather than returning `Err`. This ensures callers always get a structured report. +## Validating an AWS API Request + +`validate_aws_api_request` accepts raw service, operation, HTTP, trait, and request-parameter context. It owns operation +classification, deterministic CloudFormation resource-type selection, request-to-template modeling, schema-backed property +mapping, and diagnostic scoping to explicitly modeled properties: + +```rust +use rego_engine::RegoEngine; +use schema_validator::SchemaValidator; +use validation_engine::{ + AwsApiRequest, AwsApiValue, EngineConfig, ValidateConfig, validate_aws_api_request, +}; + +let engine = RegoEngine::new(EngineConfig::default())?; +let schema_validator = SchemaValidator::default(); +let request = AwsApiRequest::new( + "s3", + "CreateBucket", + [ + ("Bucket".into(), AwsApiValue::String { value: "example-bucket".into() }), + ], +) +.with_service_prefix("s3") +.with_http_method("PUT"); + +let result = validate_aws_api_request( + &engine, + &schema_validator, + &request, + ValidateConfig::default(), +)?; +if let Some(report) = &result.report { + for diagnostic in &report.diagnostics { + println!("{}: {}", diagnostic.rule_id, diagnostic.message); + } +} else { + println!("{:?}: {}", result.status, result.reason); +} +``` + +`AwsApiValue` preserves bytes and 64-bit integer widths and explicitly marks unsupported values. Exact `TemplateBody` +bytes are validated without rewriting; `TemplateURL` is skipped because validation is offline. Every result includes +an operation kind, validation status, optional template source, resource candidates, and reason. `Validated` means the +modeled template reached the normal validation pipeline; `Skipped` has no report and explains why. +`AwsApiRequestValidation` contains an `Option` directly — detailed enrichment is not supported for +synthesized API-request templates because there is no user-authored source to annotate with context. +The `template` field carries the exact bytes that were validated — the caller's original `TemplateBody` without +reserializing, or the synthesized JSON template for adapter-mapped requests — so consumers can display the modeled +template that produced the diagnostics. It is `None` when the request was skipped. +Use `validate_aws_api_request_with_path` when the embedding application needs a custom report path. + +**Deterministic closed-adapter contract.** Operation-to-resource mapping uses a generated adapter catalog keyed by +case-normalized canonical `service_name` and exact operation name. The catalog is produced by +`data-source/scripts/generate_aws_api_catalog.py` from each resource type's own provider handler metadata, resolved +against botocore service models and structurally verified against the compiled CloudFormation schemas; it covers +create and delete lifecycles for roughly seventy percent of all resource types plus curated update entries. Each +adapter declares one CloudFormation resource type with explicit request-parameter-to-property pairs. Unregistered +operations never receive an *inferred* resource type and are classified as `UnmappedMutation` (or +`DataPlaneMutation` for data-plane verbs) with `Skipped` status. + +**Strict all-supplied-state mapping.** Template synthesis is all-or-nothing: every request parameter the caller +supplies must either (a) map to a resource property with a representable value, or (b) be an explicitly safe-to-ignore +field (idempotency tokens, DryRun, or a declared primary identifier on update operations). If any supplied parameter +fails both conditions — because it has no mapping, or its value cannot be type-matched to the target property — +synthesis is SKIPPED and the reason names the offending parameter. This guarantees that validated templates faithfully +represent the full caller-supplied state: no parameter is ever silently omitted from the synthesized template. + +Cloud Control `UpdateResource` and `DeleteResource` may report a known `TypeName` supplied explicitly by the request, +but they never synthesize state. There is no fuzzy inference, substring matching, or generic property-name guessing. +`TemplateBody` validation is restricted to the closed set of CloudFormation operations that accept it; +`TypeName`+`DesiredState` wrapping is restricted to exact Cloud Control `CreateResource`. `service_name` is the +authoritative mapping identity; the optional signing `service_prefix` cannot override it. Case normalization supports +both CLI names (for example, `s3`) and Java SDK `SERVICE_NAME` values (for example, `S3`) without punctuation or +substring aliases. + ## Constructing an Engine Both engines take a single `EngineConfig` and return `anyhow::Result`: diff --git a/src/validation-engine/src/aws_api.rs b/src/validation-engine/src/aws_api.rs new file mode 100644 index 00000000..56108e1e --- /dev/null +++ b/src/validation-engine/src/aws_api.rs @@ -0,0 +1,2213 @@ +use diagnostics::{DetailLevel, StandardReport, Summary, ValidationReport}; +use rules::Severity; +use schema_validator::{PropertyValueType, ResourceSchemaMetadata, SchemaValidator}; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet, HashMap}; +use std::sync::LazyLock; + +use crate::{ValidateConfig, ValidationEngine, ValidationError, validate_bytes_with_path}; + +/// A recursively typed value from an AWS API request. +/// +/// Unlike JSON, this model preserves byte strings such as CloudFormation's +/// `TemplateBody`. `Unsupported` lets language bindings carry an explicit marker +/// for a runtime value they cannot represent rather than coercing it silently. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Enum))] +#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")] +pub enum AwsApiValue { + Null, + Boolean { value: bool }, + Integer { value: i64 }, + UnsignedInteger { value: u64 }, + Number { value: f64 }, + String { value: String }, + Bytes { value: Vec }, + Array { items: Vec }, + Object { entries: HashMap }, + Unsupported { type_name: String }, +} + +impl AwsApiValue { + /// Converts a JSON value without losing integer width. + pub fn from_json(value: serde_json::Value) -> Self { + match value { + serde_json::Value::Null => Self::Null, + serde_json::Value::Bool(value) => Self::Boolean { value }, + serde_json::Value::Number(value) => { + if let Some(value) = value.as_i64() { + Self::Integer { value } + } else if let Some(value) = value.as_u64() { + Self::UnsignedInteger { value } + } else if let Some(value) = value.as_f64() { + Self::Number { value } + } else { + Self::Unsupported { type_name: "JSON number".into() } + } + } + serde_json::Value::String(value) => Self::String { value }, + serde_json::Value::Array(items) => Self::Array { items: items.into_iter().map(Self::from_json).collect() }, + serde_json::Value::Object(entries) => Self::Object { + entries: entries.into_iter().map(|(key, value)| (key, Self::from_json(value))).collect(), + }, + } + } + + /// Converts to JSON when this value and all of its children are JSON-safe. + pub fn to_json(&self) -> Result { + self.json_value().ok_or_else(|| match self { + Self::Bytes { .. } => "byte strings are not JSON values".to_string(), + Self::Number { .. } => "non-finite numbers are not JSON values".to_string(), + Self::Unsupported { type_name } => format!("{type_name} is not a supported request value"), + _ => "a nested request value is not JSON-compatible".to_string(), + }) + } + + fn json_value(&self) -> Option { + match self { + Self::Null => Some(serde_json::Value::Null), + Self::Boolean { value } => Some(serde_json::Value::Bool(*value)), + Self::Integer { value } => Some(serde_json::json!(value)), + Self::UnsignedInteger { value } => Some(serde_json::json!(value)), + Self::Number { value } => serde_json::Number::from_f64(*value).map(serde_json::Value::Number), + Self::String { value } => Some(serde_json::Value::String(value.clone())), + Self::Bytes { .. } | Self::Unsupported { .. } => None, + Self::Array { items } => { + items.iter().map(Self::json_value).collect::>>().map(serde_json::Value::Array) + } + Self::Object { entries } => entries + .iter() + .map(|(key, value)| value.json_value().map(|value| (key.clone(), value))) + .collect::>>() + .map(serde_json::Value::Object), + } + } +} + +impl From for AwsApiValue { + fn from(value: serde_json::Value) -> Self { + Self::from_json(value) + } +} + +/// AWS service, operation, and input values needed to model one API request as +/// CloudFormation resource state. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Record))] +#[serde(rename_all = "camelCase")] +pub struct AwsApiRequestContext { + pub service_name: String, + pub operation_name: String, + pub parameters: HashMap, + #[serde(default, skip_serializing_if = "Option::is_none")] + #[cfg_attr(feature = "uniffi-bindings", uniffi(default))] + pub service_prefix: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + #[cfg_attr(feature = "uniffi-bindings", uniffi(default))] + pub http_method: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + #[cfg_attr(feature = "uniffi-bindings", uniffi(default))] + pub is_read_only: Option, +} + +/// Idiomatic Rust name for the AWS API request context record. +pub type AwsApiRequest = AwsApiRequestContext; + +impl AwsApiRequestContext { + pub fn new( + service_name: impl Into, + operation_name: impl Into, + parameters: impl IntoIterator, + ) -> Self { + Self { + service_name: service_name.into(), + operation_name: operation_name.into(), + parameters: parameters.into_iter().collect(), + service_prefix: None, + http_method: None, + is_read_only: None, + } + } + + pub fn with_service_prefix(mut self, service_prefix: impl Into) -> Self { + self.service_prefix = Some(service_prefix.into()); + self + } + + pub fn with_http_method(mut self, http_method: impl Into) -> Self { + self.http_method = Some(http_method.into()); + self + } + + pub fn with_read_only(mut self, is_read_only: bool) -> Self { + self.is_read_only = Some(is_read_only); + self + } + + fn default_file_path(&self) -> String { + format!("aws-api://{}/{}", self.service_name, self.operation_name) + } +} + +/// Closed classification of an AWS API operation. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Enum))] +#[serde(rename_all = "SCREAMING_SNAKE_CASE")] +pub enum AwsApiOperationKind { + ReadOnly, + CloudFormationCreate, + CloudFormationUpdate, + CloudFormationDelete, + DataPlaneMutation, + UnmappedMutation, +} + +/// Whether a request reached template validation or was conservatively skipped. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Enum))] +#[serde(rename_all = "SCREAMING_SNAKE_CASE")] +pub enum AwsApiRequestValidationStatus { + Validated, + Skipped, +} + +/// Provenance of the template validated for an AWS API request. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Enum))] +#[serde(rename_all = "SCREAMING_SNAKE_CASE")] +pub enum AwsApiTemplateSource { + TemplateBody, + CloudControlDesiredState, + SynthesizedCreate, + SynthesizedUpdate, +} + +/// Canonical result for AWS API request validation. +/// +/// Contains standard diagnostics only — detailed enrichment is not meaningful +/// for synthesized API-request templates because there is no user-authored +/// source to annotate with context. +#[derive(Debug, Clone, Serialize)] +#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Record))] +#[serde(rename_all = "camelCase")] +#[must_use] +pub struct AwsApiRequestValidation { + pub operation_kind: AwsApiOperationKind, + pub status: AwsApiRequestValidationStatus, + pub template_source: Option, + pub resource_types: Vec, + pub reason: String, + pub report: Option, + /// The exact template bytes that were validated, or `None` when the request + /// was skipped. For `TemplateBody` requests, this is the caller's original + /// bytes without reserializing. For synthesized requests, this is the + /// generated JSON template. Consumers can display this to show the modeled + /// template that produced the diagnostics. + #[serde(default, skip_serializing_if = "Option::is_none")] + #[cfg_attr(feature = "uniffi-bindings", uniffi(default))] + pub template: Option>, +} + +/// Classifies, models, and validates one AWS API request entirely offline. +pub fn validate_aws_api_request( + engine: &dyn ValidationEngine, + schema_validator: &SchemaValidator, + request: &AwsApiRequest, + config: ValidateConfig, +) -> Result { + validate_aws_api_request_with_path(engine, schema_validator, request, config, request.default_file_path()) +} + +/// Same as [`validate_aws_api_request`], with an explicit report path supplied +/// by the embedding application. +pub fn validate_aws_api_request_with_path( + engine: &dyn ValidationEngine, + schema_validator: &SchemaValidator, + request: &AwsApiRequest, + config: ValidateConfig, + file_path: String, +) -> Result { + let classification = classify_operation(request, schema_validator)?; + let synthesis = synthesize_request(request, &classification, schema_validator)?; + let Some(template) = synthesis.template else { + return Ok(AwsApiRequestValidation { + operation_kind: classification.kind, + status: AwsApiRequestValidationStatus::Skipped, + template_source: None, + resource_types: synthesis.resource_types, + reason: synthesis.reason, + report: None, + template: None, + }); + }; + + // Force standard detail level — detailed enrichment is not meaningful for + // synthesized API-request templates (no user-authored source to annotate). + let standard_config = ValidateConfig { detail_level: DetailLevel::Standard, ..config }; + let mut report = validate_bytes_with_path(engine, schema_validator, &template, standard_config, file_path)?; + if let Some(properties) = synthesis.diagnostic_properties.as_ref() { + scope_synthesized_report(&mut report, properties); + } + Ok(AwsApiRequestValidation { + operation_kind: classification.kind, + status: AwsApiRequestValidationStatus::Validated, + template_source: synthesis.source, + resource_types: synthesis.resource_types, + reason: synthesis.reason, + report: Some(report.to_standard()), + template: Some(template), + }) +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)] +#[serde(rename_all = "lowercase")] +enum AdapterPhase { + Create, + Update, + Delete, +} + +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +struct PropertyMapping { + source: String, + target: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +struct OperationAdapter { + service: String, + operation: String, + phase: AdapterPhase, + cfn_type: String, + mappings: Vec, + /// Request-control fields safe to ignore during all-or-nothing synthesis. + #[serde(default)] + ignored_inputs: Vec, +} + +#[derive(Debug, Deserialize)] +struct OperationCatalog { + format_version: u32, + adapters: Vec, +} + +// These entries exposed dependent or ambiguous provider permissions in an +// older generated artifact. Filtering them here keeps shipped catalogs +// conservative while the maintenance pipeline catches up. +const REJECTED_CATALOG_OPERATIONS: &[(&str, &str)] = &[ + ("acm", "RemoveTagsFromCertificate"), + ("logs", "StartQuery"), + ("quicksight", "CreateTopic"), + ("quicksight", "DeleteTopic"), + ("robomaker", "DeregisterRobot"), +]; + +fn is_rejected_catalog_operation(service: &str, operation: &str) -> bool { + REJECTED_CATALOG_OPERATIONS.iter().any(|(candidate_service, candidate_operation)| { + *candidate_service == service && *candidate_operation == operation + }) +} + +/// Generated by `data-source/scripts/generate_aws_api_catalog.py`: each entry is +/// derived from the resource type's own provider handler metadata, resolved +/// against botocore service models, and structurally verified against the +/// compiled CloudFormation schemas. Only exact service+operation keys resolve; +/// unregistered operations stay unmapped. +static ADAPTER_REGISTRY: LazyLock, String>> = + LazyLock::new(|| parse_adapter_registry(&data_source::embedded::AWS_API_OPERATION_CATALOG_BYTES)); + +fn parse_adapter_registry(bytes: &[u8]) -> Result, String> { + let catalog: OperationCatalog = serde_json::from_slice(bytes) + .map_err(|error| format!("embedded AWS API operation catalog is invalid: {error}"))?; + if catalog.format_version != 1 { + return Err(format!("unsupported AWS API operation catalog format {}", catalog.format_version)); + } + let mut registry = HashMap::new(); + for adapter in catalog.adapters { + if adapter.service.trim().is_empty() + || adapter.operation.trim().is_empty() + || adapter.cfn_type.trim().is_empty() + { + return Err("AWS API operation catalog identities must not be blank".into()); + } + let key = (normalize_service(&adapter.service), adapter.operation.clone()); + if is_rejected_catalog_operation(&key.0, &key.1) { + continue; + } + if let Some(previous) = registry.insert(key, adapter) { + return Err(format!("duplicate AWS API operation catalog key {}:{}", previous.service, previous.operation)); + } + } + Ok(registry) +} + +fn adapter_registry() -> Result<&'static HashMap<(String, String), OperationAdapter>, ValidationError> { + ADAPTER_REGISTRY.as_ref().map_err(|message| ValidationError::Engine(message.clone())) +} + +/// CloudFormation operations that accept TemplateBody per botocore service +/// definitions. Only these exact service+operation pairs treat a TemplateBody +/// parameter as a CloudFormation template. +const TEMPLATE_BODY_OPERATIONS: &[(&str, &str)] = &[ + ("cloudformation", "CreateChangeSet"), + ("cloudformation", "CreateStack"), + ("cloudformation", "CreateStackSet"), + ("cloudformation", "EstimateTemplateCost"), + ("cloudformation", "GetTemplateSummary"), + ("cloudformation", "UpdateStack"), + ("cloudformation", "UpdateStackSet"), + ("cloudformation", "ValidateTemplate"), +]; + +/// CLI and Java SDK service names differ only in casing for the supported adapters. +fn normalize_service(name: &str) -> String { + name.to_ascii_lowercase() +} + +fn lookup_adapter(service: &str, operation: &str) -> Result, ValidationError> { + let key = (normalize_service(service), operation.to_string()); + Ok(adapter_registry()?.get(&key)) +} + +fn is_template_body_operation(service: &str, operation: &str) -> bool { + let normalized = normalize_service(service); + TEMPLATE_BODY_OPERATIONS.iter().any(|(s, o)| normalize_service(s) == normalized && *o == operation) +} + +fn template_body_operation_kind(service: &str, operation: &str) -> Option { + if normalize_service(service) != "cloudformation" { + return None; + } + match operation { + "CreateChangeSet" | "CreateStack" | "CreateStackSet" => Some(AwsApiOperationKind::CloudFormationCreate), + "UpdateStack" | "UpdateStackSet" => Some(AwsApiOperationKind::CloudFormationUpdate), + "EstimateTemplateCost" | "GetTemplateSummary" | "ValidateTemplate" => Some(AwsApiOperationKind::ReadOnly), + _ => None, + } +} + +fn is_cloud_control_service(service: &str) -> bool { + normalize_service(service) == "cloudcontrol" +} +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum OperationPhase { + Read, + Create, + Update, + Delete, + Data, + Unknown, +} + +#[derive(Debug, Clone)] +struct Classification { + kind: AwsApiOperationKind, + candidates: Vec, +} + +const READ_VERBS: &[&str] = &[ + "Calculate", + "Check", + "Compare", + "Contains", + "Count", + "Decode", + "Describe", + "Discover", + "Estimate", + "Filter", + "Find", + "Forecast", + "Get", + "Head", + "Is", + "List", + "Lookup", + "Preview", + "Query", + "Read", + "Resolve", + "Retrieve", + "Sample", + "Scan", + "Search", + "Select", + "Simulate", + "Validate", + "Verify", + "View", +]; +const DATA_PLANE_VERBS: &[&str] = &[ + "Analyze", + "Chat", + "Complete", + "Convert", + "Converse", + "Decrypt", + "Deliver", + "Encrypt", + "Execute", + "Generate", + "Infer", + "Invoke", + "Meter", + "Notify", + "Post", + "Predict", + "Publish", + "Receive", + "Recognize", + "Render", + "Respond", + "Send", + "Signal", + "Sign", + "Stream", + "Synthesize", + "Test", + "Translate", + "Upload", + "Write", +]; + +const MODIFIER_PREFIXES: &[&str] = &["Admin", "Batch", "Bulk", "Transact"]; + +fn classify_operation( + request: &AwsApiRequest, + schema_validator: &SchemaValidator, +) -> Result { + if let Some(kind) = template_body_operation_kind(&request.service_name, &request.operation_name) { + return Ok(Classification { kind, candidates: Vec::new() }); + } + + // The modeled read-only trait is authoritative even over a registered adapter. + if request.is_read_only == Some(true) { + return Ok(Classification { kind: AwsApiOperationKind::ReadOnly, candidates: Vec::new() }); + } + + if let Some(adapter) = lookup_adapter(&request.service_name, &request.operation_name)? { + let kind = match adapter.phase { + AdapterPhase::Create => AwsApiOperationKind::CloudFormationCreate, + AdapterPhase::Update => AwsApiOperationKind::CloudFormationUpdate, + AdapterPhase::Delete => AwsApiOperationKind::CloudFormationDelete, + }; + return Ok(Classification { kind, candidates: vec![adapter.cfn_type.clone()] }); + } + + let words = operation_words(&request.operation_name); + let verb = effective_verb(&words); + let phase = operation_phase(request, verb); + + if phase == OperationPhase::Read { + return Ok(Classification { kind: AwsApiOperationKind::ReadOnly, candidates: Vec::new() }); + } + if phase == OperationPhase::Data { + return Ok(Classification { kind: AwsApiOperationKind::DataPlaneMutation, candidates: Vec::new() }); + } + + if is_cloud_control_service(&request.service_name) { + let is_resource_op = + matches!(request.operation_name.as_str(), "CreateResource" | "UpdateResource" | "DeleteResource"); + if is_resource_op && let Some(type_name) = explicit_valid_type_name(request, schema_validator) { + let kind = match request.operation_name.as_str() { + "CreateResource" => AwsApiOperationKind::CloudFormationCreate, + "DeleteResource" => AwsApiOperationKind::CloudFormationDelete, + _ => AwsApiOperationKind::UnmappedMutation, + }; + return Ok(Classification { kind, candidates: vec![type_name] }); + } + } + + // Unknown mutation: classify by verb family but never assign resource types. + let kind = if DATA_PLANE_IF_UNMAPPED_VERBS.contains(&verb) { + AwsApiOperationKind::DataPlaneMutation + } else { + AwsApiOperationKind::UnmappedMutation + }; + Ok(Classification { kind, candidates: Vec::new() }) +} + +const DATA_PLANE_IF_UNMAPPED_VERBS: &[&str] = + &["Execute", "Invoke", "Post", "Publish", "Put", "Send", "Upload", "Write"]; + +fn operation_phase(request: &AwsApiRequest, verb: &str) -> OperationPhase { + if request.is_read_only == Some(true) || READ_VERBS.contains(&verb) { + return OperationPhase::Read; + } + if DATA_PLANE_VERBS.contains(&verb) { + return OperationPhase::Data; + } + if CREATE_VERBS.contains(&verb) { + return OperationPhase::Create; + } + if UPDATE_VERBS.contains(&verb) { + return OperationPhase::Update; + } + if DELETE_VERBS.contains(&verb) { + return OperationPhase::Delete; + } + match request.http_method.as_deref().map(str::to_ascii_uppercase).as_deref() { + Some("GET" | "HEAD") => return OperationPhase::Read, + Some("DELETE") => return OperationPhase::Delete, + _ => {} + } + OperationPhase::Unknown +} + +const CREATE_VERBS: &[&str] = &[ + "Add", + "Allocate", + "Build", + "Clone", + "Copy", + "Create", + "Define", + "Deploy", + "Import", + "Index", + "Initialize", + "Install", + "Instantiate", + "Invite", + "Issue", + "Join", + "Launch", + "Provision", + "Purchase", + "Register", + "Request", + "Restore", + "Run", + "Schedule", + "Start", + "Submit", +]; +const UPDATE_VERBS: &[&str] = &[ + "Accept", + "Activate", + "Apply", + "Approve", + "Assign", + "Associate", + "Attach", + "Authorize", + "Change", + "Configure", + "Connect", + "Deactivate", + "Decrease", + "Disable", + "Disassociate", + "Dissociate", + "Detach", + "Enable", + "Grant", + "Increase", + "Link", + "Lock", + "Merge", + "Modify", + "Move", + "Promote", + "Put", + "Reboot", + "Refresh", + "Replace", + "Reset", + "Resize", + "Restart", + "Resume", + "Rotate", + "Set", + "Share", + "Subscribe", + "Suspend", + "Swap", + "Tag", + "Transfer", + "Unassign", + "Unlock", + "Unshare", + "Unsubscribe", + "Untag", + "Update", + "Upgrade", +]; +const DELETE_VERBS: &[&str] = &[ + "Abort", + "Block", + "Cancel", + "Close", + "Decline", + "Delete", + "Deny", + "Deprovision", + "Deregister", + "Destroy", + "Discard", + "Dispose", + "Expire", + "Forget", + "Leave", + "Purge", + "Reject", + "Release", + "Remove", + "Retire", + "Revoke", + "Shutdown", + "Stop", + "Terminate", + "Unregister", +]; + +fn operation_words(operation_name: &str) -> Vec { + let characters: Vec = operation_name.chars().collect(); + if characters.is_empty() { + return Vec::new(); + } + let mut words = Vec::new(); + let mut start = 0; + for index in 1..characters.len() { + let previous = characters[index - 1]; + let current = characters[index]; + let next = characters.get(index + 1).copied(); + let boundary = (current.is_ascii_digit() && !previous.is_ascii_digit()) + || (!current.is_ascii_digit() && previous.is_ascii_digit()) + || (current.is_ascii_uppercase() && previous.is_ascii_lowercase()) + || (current.is_ascii_uppercase() + && previous.is_ascii_uppercase() + && next.is_some_and(|next| next.is_ascii_lowercase())); + if boundary { + words.push(characters[start..index].iter().collect()); + start = index; + } + } + words.push(characters[start..].iter().collect()); + words +} + +fn effective_verb(words: &[String]) -> &str { + if words.len() > 1 && MODIFIER_PREFIXES.contains(&words[0].as_str()) { + &words[1] + } else { + words.first().map(String::as_str).unwrap_or("") + } +} + +fn explicit_valid_type_name(request: &AwsApiRequest, schema_validator: &SchemaValidator) -> Option { + match request.parameters.get("TypeName") { + Some(AwsApiValue::String { value }) if schema_validator.has_resource_type(value) => Some(value.clone()), + _ => None, + } +} +struct Synthesis { + template: Option>, + source: Option, + reason: String, + resource_types: Vec, + diagnostic_properties: Option>, +} + +impl Synthesis { + fn skipped(reason: impl Into, resource_types: Vec) -> Self { + Self { template: None, source: None, reason: reason.into(), resource_types, diagnostic_properties: None } + } +} + +fn synthesize_request( + request: &AwsApiRequest, + classification: &Classification, + schema_validator: &SchemaValidator, +) -> Result { + let is_cfn_op = is_template_body_operation(&request.service_name, &request.operation_name); + + if is_cfn_op { + if let Some(template) = template_body_bytes(request.parameters.get("TemplateBody")) { + return Ok(Synthesis { + template: Some(template), + source: Some(AwsApiTemplateSource::TemplateBody), + reason: "using exact request TemplateBody".into(), + resource_types: Vec::new(), + diagnostic_properties: None, + }); + } + if request.parameters.contains_key("TemplateURL") { + return Ok(Synthesis::skipped("TemplateURL content is unavailable to the offline validator", Vec::new())); + } + } + + if classification.kind == AwsApiOperationKind::ReadOnly { + return Ok(Synthesis::skipped("read-only calls do not need validation", Vec::new())); + } + + let is_cloud_control = is_cloud_control_service(&request.service_name); + if is_cloud_control + && request.operation_name == "CreateResource" + && request.parameters.contains_key("TypeName") + && request.parameters.contains_key("DesiredState") + { + return desired_state_template(request, schema_validator); + } + + if is_cloud_control && request.operation_name == "UpdateResource" { + let type_names = explicit_valid_type_name(request, schema_validator).map(|t| vec![t]).unwrap_or_default(); + return Ok(Synthesis::skipped( + "Cloud Control UpdateResource uses PatchDocument and cannot be synthesized", + type_names, + )); + } + + adapter_template(request, classification, schema_validator) +} + +fn template_body_bytes(value: Option<&AwsApiValue>) -> Option> { + match value { + Some(AwsApiValue::Bytes { value }) if !value.is_empty() => Some(value.clone()), + Some(AwsApiValue::String { value }) if !value.is_empty() => Some(value.as_bytes().to_vec()), + _ => None, + } +} + +fn desired_state_template( + request: &AwsApiRequest, + schema_validator: &SchemaValidator, +) -> Result { + let Some(AwsApiValue::String { value: type_name }) = request.parameters.get("TypeName") else { + return Ok(Synthesis::skipped("DesiredState has no known CloudFormation TypeName", Vec::new())); + }; + if !schema_validator.has_resource_type(type_name) { + return Ok(Synthesis::skipped("DesiredState has no known CloudFormation TypeName", Vec::new())); + } + let Some(desired_state) = request.parameters.get("DesiredState") else { + return Ok(Synthesis::skipped("DesiredState is missing", vec![type_name.clone()])); + }; + let properties = match desired_state { + AwsApiValue::String { value } if !value.is_empty() => serde_json::from_str(value), + AwsApiValue::Bytes { value } if !value.is_empty() => serde_json::from_slice(value), + _ => return Ok(Synthesis::skipped("DesiredState is missing", vec![type_name.clone()])), + }; + let properties: serde_json::Value = match properties { + Ok(properties) => properties, + Err(_) => return Ok(Synthesis::skipped("DesiredState is not valid JSON", vec![type_name.clone()])), + }; + let Some(properties) = properties.as_object() else { + return Ok(Synthesis::skipped("DesiredState is not a JSON object", vec![type_name.clone()])); + }; + Ok(Synthesis { + template: Some(resource_template(type_name, properties)?), + source: Some(AwsApiTemplateSource::CloudControlDesiredState), + reason: "wrapped exact Cloud Control desired state".into(), + resource_types: vec![type_name.clone()], + diagnostic_properties: None, + }) +} + +fn adapter_template( + request: &AwsApiRequest, + classification: &Classification, + schema_validator: &SchemaValidator, +) -> Result { + if !matches!( + classification.kind, + AwsApiOperationKind::CloudFormationCreate | AwsApiOperationKind::CloudFormationUpdate + ) { + return Ok(Synthesis::skipped( + "classification has no representable resource state", + classification.candidates.clone(), + )); + } + if classification.candidates.len() != 1 { + return Ok(Synthesis::skipped( + "no adapter maps this operation to a CloudFormation resource", + classification.candidates.clone(), + )); + } + + let type_name = &classification.candidates[0]; + let Some(schema) = schema_validator.resource_schema_metadata(type_name) else { + return Ok(Synthesis::skipped("CloudFormation resource type is unknown", vec![type_name.clone()])); + }; + + let adapter = lookup_adapter(&request.service_name, &request.operation_name)?; + let Some(adapter) = adapter else { + return Ok(Synthesis::skipped( + "no adapter maps this operation to a CloudFormation resource", + vec![type_name.clone()], + )); + }; + + let properties = match map_adapter_properties(&request.parameters, &schema, adapter)? { + AdapterMappingResult::Mapped(properties) => properties, + AdapterMappingResult::Skip(reason) => { + return Ok(Synthesis::skipped(reason, vec![type_name.clone()])); + } + }; + + if properties.is_empty() { + return Ok(Synthesis::skipped("no request parameters map to resource properties", vec![type_name.clone()])); + } + + let diagnostic_properties = Some(properties.keys().cloned().collect::>()); + let source = if adapter.phase == AdapterPhase::Update { + AwsApiTemplateSource::SynthesizedUpdate + } else { + AwsApiTemplateSource::SynthesizedCreate + }; + let reason = if adapter.phase == AdapterPhase::Update { + "synthesized explicitly updated CloudFormation properties" + } else { + "synthesized one unambiguous CloudFormation resource" + }; + let template_properties: serde_json::Map = properties.into_iter().collect(); + Ok(Synthesis { + template: Some(resource_template(type_name, &template_properties)?), + source: Some(source), + reason: reason.into(), + resource_types: vec![type_name.clone()], + diagnostic_properties, + }) +} + +#[derive(Debug)] +enum AdapterMappingResult { + Mapped(BTreeMap), + Skip(String), +} + +fn map_adapter_properties( + parameters: &HashMap, + schema: &ResourceSchemaMetadata, + adapter: &OperationAdapter, +) -> Result { + let mut excluded = schema.read_only_properties.clone(); + if adapter.phase == AdapterPhase::Update { + excluded.extend(schema.primary_identifier_properties.iter().cloned()); + } + + let mut sources = BTreeSet::new(); + let mut targets = BTreeSet::new(); + let mut mapped_sources: BTreeSet<&str> = BTreeSet::new(); + let mut mapped = BTreeMap::new(); + for mapping in &adapter.mappings { + if !sources.insert(mapping.source.as_str()) { + return Err(ValidationError::Engine(format!( + "adapter {}:{} has duplicate source parameter '{}'", + adapter.service, adapter.operation, mapping.source + ))); + } + if !targets.insert(mapping.target.as_str()) { + return Err(ValidationError::Engine(format!( + "adapter {}:{} has duplicate target property '{}'", + adapter.service, adapter.operation, mapping.target + ))); + } + let Some(accepted_types) = schema.property_types.get(&mapping.target) else { + return Err(ValidationError::Engine(format!( + "adapter {}:{} targets property '{}' which does not exist on {}", + adapter.service, adapter.operation, mapping.target, adapter.cfn_type + ))); + }; + if excluded.contains(&mapping.target) { + return Err(ValidationError::Engine(format!( + "adapter {}:{} targets excluded property '{}' on {}", + adapter.service, adapter.operation, mapping.target, adapter.cfn_type + ))); + } + let Some(value) = parameters.get(&mapping.source) else { + continue; + }; + mapped_sources.insert(&mapping.source); + match mapped_value(value, accepted_types, &mapping.target) { + Some(json_value) => { + mapped.insert(mapping.target.clone(), json_value); + } + None => { + return Ok(AdapterMappingResult::Skip(format!( + "parameter '{}' cannot be represented as property '{}' on {}", + mapping.source, mapping.target, adapter.cfn_type + ))); + } + } + } + + // Build the set of parameters that are safe to ignore: explicitly declared + // ignored_inputs, plus primary identifier properties for update adapters. + let mut ignored: BTreeSet<&str> = adapter.ignored_inputs.iter().map(String::as_str).collect(); + if adapter.phase == AdapterPhase::Update { + ignored.extend(schema.primary_identifier_properties.iter().map(String::as_str)); + } + + // All-or-nothing: every supplied parameter must either be mapped or + // in the ignored set. + for param_name in parameters.keys() { + if mapped_sources.contains(param_name.as_str()) { + continue; + } + if ignored.contains(param_name.as_str()) { + continue; + } + return Ok(AdapterMappingResult::Skip(format!( + "parameter '{}' has no mapping to a property on {}", + param_name, adapter.cfn_type + ))); + } + Ok(AdapterMappingResult::Mapped(mapped)) +} + +fn resource_template( + type_name: &str, + properties: &serde_json::Map, +) -> Result, ValidationError> { + serde_json::to_vec(&serde_json::json!({ + "AWSTemplateFormatVersion": "2010-09-09", + "Resources": { + "Resource": { + "Type": type_name, + "Properties": properties, + } + } + })) + .map_err(|error| ValidationError::Engine(format!("failed to serialize synthesized template: {error}"))) +} + +fn mapped_value( + value: &AwsApiValue, + accepted_types: &BTreeSet, + property_name: &str, +) -> Option { + // Many AWS APIs use string maps for tags, while CloudFormation uses + // Key/Value object arrays for the same resource state. + if property_name == "Tags" + && accepts_type(accepted_types, PropertyValueType::Array) + && let AwsApiValue::Object { entries } = value + && entries.values().all(|value| matches!(value, AwsApiValue::String { .. })) + { + let mut tags: Vec<(&String, &AwsApiValue)> = entries.iter().collect(); + tags.sort_by_key(|(key, _)| key.as_str()); + return Some(serde_json::Value::Array( + tags.into_iter() + .filter_map(|(key, value)| match value { + AwsApiValue::String { value } => Some(serde_json::json!({"Key": key, "Value": value})), + _ => None, + }) + .collect(), + )); + } + if value_matches_types(value, accepted_types) { + return value.json_value(); + } + None +} + +fn accepts_type(types: &BTreeSet, expected: PropertyValueType) -> bool { + types.contains(&PropertyValueType::Any) || types.contains(&expected) +} + +fn value_matches_types(value: &AwsApiValue, types: &BTreeSet) -> bool { + let accepts_any = types.contains(&PropertyValueType::Any); + match value { + AwsApiValue::Array { items } => { + (accepts_any || types.contains(&PropertyValueType::Array)) && items.iter().all(is_scalar_api_value) + } + AwsApiValue::Object { .. } => false, + AwsApiValue::Boolean { .. } => accepts_any || types.contains(&PropertyValueType::Boolean), + AwsApiValue::Integer { .. } | AwsApiValue::UnsignedInteger { .. } => { + accepts_any || types.contains(&PropertyValueType::Integer) || types.contains(&PropertyValueType::Number) + } + AwsApiValue::Number { .. } => accepts_any || types.contains(&PropertyValueType::Number), + AwsApiValue::String { .. } => accepts_any || types.contains(&PropertyValueType::String), + AwsApiValue::Null | AwsApiValue::Bytes { .. } | AwsApiValue::Unsupported { .. } => false, + } +} + +fn is_scalar_api_value(value: &AwsApiValue) -> bool { + matches!( + value, + AwsApiValue::Boolean { .. } + | AwsApiValue::Integer { .. } + | AwsApiValue::UnsignedInteger { .. } + | AwsApiValue::Number { .. } + | AwsApiValue::String { .. } + ) +} +fn scope_synthesized_report(report: &mut ValidationReport, properties: &BTreeSet) { + let before = report.diagnostics.len(); + report.diagnostics.retain(|diagnostic| { + diagnostic.property_path.as_deref().is_some_and(|path| diagnostic_in_scope(path, properties)) + }); + let removed = before.saturating_sub(report.diagnostics.len()) as u32; + report.metadata.suppressed = report.metadata.suppressed.saturating_add(removed); + report.metadata.counts = summarize_diagnostics(&report.diagnostics); +} + +fn diagnostic_in_scope(property_path: &str, properties: &BTreeSet) -> bool { + properties.iter().any(|property_name| { + [format!("Properties.{property_name}"), format!("/Properties/{property_name}")].into_iter().any(|marker| { + property_path.find(&marker).is_some_and(|start| { + let end = start + marker.len(); + end == property_path.len() + || property_path[end..].chars().next().is_some_and(|separator| matches!(separator, '.' | '[' | '/')) + }) + }) + }) +} + +fn summarize_diagnostics(diagnostics: &[diagnostics::Diagnostic]) -> Summary { + let fatal = diagnostics.iter().filter(|diagnostic| diagnostic.severity == Severity::Fatal).count() as u32; + let errors = diagnostics.iter().filter(|diagnostic| diagnostic.severity == Severity::Error).count() as u32; + let warnings = diagnostics.iter().filter(|diagnostic| diagnostic.severity == Severity::Warn).count() as u32; + let debug = diagnostics.iter().filter(|diagnostic| diagnostic.severity == Severity::Debug).count() as u32; + let informational = diagnostics.len() as u32 - fatal - errors - warnings - debug; + Summary { fatal, errors, warnings, informational, debug } +} +#[cfg(test)] +mod tests { + use super::*; + use diagnostics::{Diagnostic, PhaseMetric}; + use rules::{RuleInfo, RuleMetadataEntry}; + use std::sync::Arc; + use template_model::SemanticModel; + + struct NoopEngine { + metadata: HashMap, + init_metric: PhaseMetric, + } + + impl Default for NoopEngine { + fn default() -> Self { + Self { metadata: HashMap::new(), init_metric: PhaseMetric { duration_ms: 0.0 } } + } + } + + impl ValidationEngine for NoopEngine { + fn engine_name(&self) -> &str { + "noop" + } + + fn evaluate_rules( + &self, + _model: &Arc, + _config: &ValidateConfig, + ) -> Result, ValidationError> { + Ok(Vec::new()) + } + + fn list_rules(&self) -> Vec { + Vec::new() + } + + fn rule_metadata(&self) -> &HashMap { + &self.metadata + } + + fn external_rule_metadata(&self) -> HashMap { + HashMap::new() + } + + fn init_metric(&self) -> &PhaseMetric { + &self.init_metric + } + } + + fn value(value: serde_json::Value) -> AwsApiValue { + AwsApiValue::from_json(value) + } + + fn request(service: &str, operation: &str, parameters: serde_json::Value) -> AwsApiRequest { + let parameters: HashMap = parameters + .as_object() + .expect("test parameters must be an object") + .iter() + .map(|(name, value)| (name.clone(), AwsApiValue::from_json(value.clone()))) + .collect(); + AwsApiRequest::new(service, operation, parameters).with_http_method("POST") + } + + fn synthesized_json(request: &AwsApiRequest) -> (Classification, Synthesis, serde_json::Value) { + let schema_validator = SchemaValidator::default(); + let classification = classify_operation(request, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(request, &classification, &schema_validator).expect("synthesis succeeds"); + let template = synthesis.template.as_ref().expect("request must synthesize"); + let document = serde_json::from_slice(template).expect("template must be JSON"); + (classification, synthesis, document) + } + + fn mapping(source: &str, target: &str) -> PropertyMapping { + PropertyMapping { source: source.into(), target: target.into() } + } + + fn malformed_adapter_error(mappings: Vec) -> String { + let schema_validator = SchemaValidator::default(); + let schema = schema_validator.resource_schema_metadata("AWS::S3::Bucket").expect("S3 bucket schema must exist"); + let adapter = OperationAdapter { + service: "s3".into(), + operation: "CreateBucket".into(), + phase: AdapterPhase::Create, + cfn_type: "AWS::S3::Bucket".into(), + mappings, + ignored_inputs: Vec::new(), + }; + match map_adapter_properties(&HashMap::new(), &schema, &adapter) + .expect_err("malformed adapter must return an error") + { + ValidationError::Engine(message) => message, + error => panic!("expected engine error, got {error:?}"), + } + } + #[test] + fn catalog_parser_rejects_invalid_formats_and_normalized_duplicates() { + assert!(parse_adapter_registry(b"not json").expect_err("invalid JSON must fail").contains("invalid")); + assert!( + parse_adapter_registry(br#"{"format_version":2,"adapters":[]}"#) + .expect_err("unsupported format must fail") + .contains("unsupported") + ); + let duplicate = br#"{ + "format_version": 1, + "adapters": [ + {"service":"S3","operation":"CreateBucket","phase":"create","cfn_type":"AWS::S3::Bucket","mappings":[]}, + {"service":"s3","operation":"CreateBucket","phase":"create","cfn_type":"AWS::S3::Bucket","mappings":[]} + ] + }"#; + assert!( + parse_adapter_registry(duplicate).expect_err("case-normalized duplicate must fail").contains("duplicate") + ); + let blank = br#"{ + "format_version": 1, + "adapters": [ + {"service":"","operation":"CreateBucket","phase":"create","cfn_type":"AWS::S3::Bucket","mappings":[]} + ] + }"#; + assert!(parse_adapter_registry(blank).expect_err("blank identity must fail").contains("blank")); + } + + #[test] + fn catalog_covers_the_generated_resource_universe() { + let registry = adapter_registry().expect("catalog loads"); + let creates = registry.values().filter(|a| a.phase == AdapterPhase::Create).count(); + let deletes = registry.values().filter(|a| a.phase == AdapterPhase::Delete).count(); + assert!(registry.len() >= 2000, "catalog unexpectedly small: {}", registry.len()); + assert!(creates >= 1000, "create adapters unexpectedly few: {creates}"); + assert!(deletes >= 900, "delete adapters unexpectedly few: {deletes}"); + } + + #[test] + fn catalog_operations_synthesize_beyond_the_original_services() { + let cases = [ + ("ec2", "RunInstances", "AWS::EC2::Instance"), + ("kms", "CreateKey", "AWS::KMS::Key"), + ("logs", "CreateLogGroup", "AWS::Logs::LogGroup"), + ("stepfunctions", "CreateStateMachine", "AWS::StepFunctions::StateMachine"), + ("cloudwatch", "PutMetricAlarm", "AWS::CloudWatch::Alarm"), + ("secretsmanager", "CreateSecret", "AWS::SecretsManager::Secret"), + ]; + let schema_validator = SchemaValidator::default(); + for (service, operation, expected_type) in cases { + let req = request(service, operation, serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.candidates, [expected_type], "{service}:{operation} must map to {expected_type}"); + } + } + + #[test] + fn catalog_never_contains_forbidden_or_ambiguous_operations() { + let forbidden = [ + ("ecs", "RunTask"), + ("ec2", "StartInstances"), + ("ec2", "StopInstances"), + ("iot", "StartThingRegistrationTask"), + ("lambda", "Invoke"), + ("sns", "Publish"), + ("sqs", "SendMessage"), + ("s3", "PutObject"), + ("dynamodb", "PutItem"), + ("logs", "StartQuery"), + ("acm", "RemoveTagsFromCertificate"), + ("robomaker", "DeregisterRobot"), + ("quicksight", "CreateTopic"), + ("quicksight", "DeleteTopic"), + ]; + let registry = adapter_registry().expect("catalog loads"); + for (service, operation) in forbidden { + let key = (service.to_string(), operation.to_string()); + assert!(!registry.contains_key(&key), "{service}:{operation} must never be a registered adapter"); + } + } + + #[test] + fn every_catalog_adapter_maps_cleanly_with_empty_requests() { + let schema_validator = SchemaValidator::default(); + let empty = HashMap::new(); + for adapter in adapter_registry().expect("catalog loads").values() { + let schema = schema_validator + .resource_schema_metadata(&adapter.cfn_type) + .unwrap_or_else(|| panic!("{} missing schema metadata", adapter.cfn_type)); + let result = map_adapter_properties(&empty, &schema, adapter).unwrap_or_else(|error| { + panic!("adapter {}:{} violates registry invariants: {error}", adapter.service, adapter.operation) + }); + // Empty parameters always produce Mapped (no supplied params to conflict). + assert!( + matches!(result, AdapterMappingResult::Mapped(_)), + "adapter {}:{} must accept empty parameters", + adapter.service, + adapter.operation + ); + } + } + + #[test] + fn rejected_catalog_operations_never_report_resource_types() { + let schema_validator = SchemaValidator::default(); + for (service, operation) in REJECTED_CATALOG_OPERATIONS { + let request = request(service, operation, serde_json::json!({})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert!( + classification.candidates.is_empty(), + "{service}:{operation} must not report a CloudFormation type" + ); + let synthesis = + synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none(), "{service}:{operation} must not synthesize state"); + assert!(synthesis.resource_types.is_empty(), "{service}:{operation} must not report resource types"); + } + } + + #[test] + fn nested_values_are_rejected_without_recursive_shape_mappings() { + let object_types = BTreeSet::from([PropertyValueType::Object]); + let array_types = BTreeSet::from([PropertyValueType::Array]); + let object = AwsApiValue::from_json(serde_json::json!({"lowerCamel": "value"})); + let object_array = AwsApiValue::from_json(serde_json::json!([{"lowerCamel": "value"}])); + let scalar_array = AwsApiValue::from_json(serde_json::json!(["one", "two"])); + + assert!(mapped_value(&object, &object_types, "Configuration").is_none()); + assert!(mapped_value(&object_array, &array_types, "Configurations").is_none()); + assert_eq!(mapped_value(&scalar_array, &array_types, "Names"), Some(serde_json::json!(["one", "two"]))); + } + + #[test] + fn registry_has_unique_service_operation_keys() { + let mut seen = BTreeSet::new(); + for adapter in adapter_registry().expect("catalog loads").values() { + let key = (normalize_service(&adapter.service), adapter.operation.clone()); + assert!(seen.insert(key.clone()), "duplicate adapter key: {}:{}", key.0, key.1); + } + } + + #[test] + fn registry_types_exist_in_schema_validator() { + let schema_validator = SchemaValidator::default(); + for adapter in adapter_registry().expect("catalog loads").values() { + assert!( + schema_validator.has_resource_type(&adapter.cfn_type), + "adapter {}:{} references unknown type {}", + adapter.service, + adapter.operation, + adapter.cfn_type + ); + } + } + + #[test] + fn registry_property_mappings_target_real_properties() { + let schema_validator = SchemaValidator::default(); + for adapter in adapter_registry().expect("catalog loads").values() { + let Some(schema) = schema_validator.resource_schema_metadata(&adapter.cfn_type) else { + continue; + }; + for mapping in &adapter.mappings { + assert!( + schema.property_types.contains_key(&mapping.target), + "adapter {}:{} maps to non-existent property {}.{}", + adapter.service, + adapter.operation, + adapter.cfn_type, + mapping.target + ); + } + } + } + + #[test] + fn registry_has_no_read_only_property_mappings() { + let schema_validator = SchemaValidator::default(); + for adapter in adapter_registry().expect("catalog loads").values() { + let Some(schema) = schema_validator.resource_schema_metadata(&adapter.cfn_type) else { + continue; + }; + for mapping in &adapter.mappings { + assert!( + !schema.read_only_properties.contains(&mapping.target), + "adapter {}:{} maps to read-only property {}.{}", + adapter.service, + adapter.operation, + adapter.cfn_type, + mapping.target + ); + } + } + } + + #[test] + fn registry_update_mappings_exclude_primary_identifiers() { + let schema_validator = SchemaValidator::default(); + for adapter in adapter_registry().expect("catalog loads").values() { + if adapter.phase != AdapterPhase::Update { + continue; + } + let Some(schema) = schema_validator.resource_schema_metadata(&adapter.cfn_type) else { + continue; + }; + for mapping in &adapter.mappings { + assert!( + !schema.primary_identifier_properties.contains(&mapping.target), + "update adapter {}:{} maps to primary identifier property {}.{}", + adapter.service, + adapter.operation, + adapter.cfn_type, + mapping.target + ); + } + } + } + + #[test] + fn registry_has_no_duplicate_source_or_target_mappings() { + for adapter in adapter_registry().expect("catalog loads").values() { + let mut sources = BTreeSet::new(); + let mut targets = BTreeSet::new(); + for mapping in &adapter.mappings { + assert!( + sources.insert(mapping.source.as_str()), + "adapter {}:{} has duplicate source mapping: {}", + adapter.service, + adapter.operation, + mapping.source + ); + assert!( + targets.insert(mapping.target.as_str()), + "adapter {}:{} has duplicate target mapping: {}", + adapter.service, + adapter.operation, + mapping.target + ); + } + } + } + + #[test] + fn malformed_adapter_mappings_fail_without_request_values() { + assert!(malformed_adapter_error(vec![mapping("Bucket", "NotAProperty")]).contains("does not exist")); + assert!(malformed_adapter_error(vec![mapping("Bucket", "Arn")]).contains("excluded property")); + assert!( + malformed_adapter_error(vec![mapping("Bucket", "BucketName"), mapping("Bucket", "Tags")]) + .contains("duplicate source parameter") + ); + assert!( + malformed_adapter_error(vec![mapping("Bucket", "BucketName"), mapping("OtherBucket", "BucketName")]) + .contains("duplicate target property") + ); + } + + #[test] + fn s3_create_bucket_synthesizes_with_explicit_mappings() { + let request = request("s3", "CreateBucket", serde_json::json!({"Bucket": "synthetic-bucket"})); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::S3::Bucket"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedCreate)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["BucketName"], "synthetic-bucket"); + } + + #[test] + fn s3_delete_bucket_identifies_type_without_synthesizing() { + let schema_validator = SchemaValidator::default(); + let request = request("s3", "DeleteBucket", serde_json::json!({"Bucket": "synthetic-bucket"})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationDelete); + assert_eq!(classification.candidates, ["AWS::S3::Bucket"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn dynamodb_create_table_skips_when_nested_values_are_unrepresentable() { + let schema_validator = SchemaValidator::default(); + let request = request( + "dynamodb", + "CreateTable", + serde_json::json!({ + "TableName": "Synthetic", + "KeySchema": [{"AttributeName": "id", "KeyType": "HASH"}], + "AttributeDefinitions": [{"AttributeName": "id", "AttributeType": "S"}], + "BillingMode": "PAY_PER_REQUEST" + }), + ); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::DynamoDB::Table"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none(), "nested struct arrays must skip synthesis"); + assert!( + synthesis.reason.contains("cannot be represented"), + "reason must explain the type mismatch: {}", + synthesis.reason + ); + } + + #[test] + fn dynamodb_create_table_synthesizes_with_scalar_only_parameters() { + let request = request( + "dynamodb", + "CreateTable", + serde_json::json!({"TableName": "Synthetic", "BillingMode": "PAY_PER_REQUEST"}), + ); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::DynamoDB::Table"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedCreate)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["TableName"], "Synthetic"); + assert_eq!(document["Resources"]["Resource"]["Properties"]["BillingMode"], "PAY_PER_REQUEST"); + } + + #[test] + fn dynamodb_delete_table_identifies_type_without_synthesizing() { + let schema_validator = SchemaValidator::default(); + let request = request("dynamodb", "DeleteTable", serde_json::json!({"TableName": "Synthetic"})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationDelete); + assert_eq!(classification.candidates, ["AWS::DynamoDB::Table"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn iam_create_role_synthesizes_with_explicit_mappings() { + let request = request( + "iam", + "CreateRole", + serde_json::json!({ + "RoleName": "Synthetic", + "AssumeRolePolicyDocument": "{\"Version\":\"2012-10-17\",\"Statement\":[]}", + "Tags": {"Team": "CLI"} + }), + ); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::IAM::Role"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedCreate)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["RoleName"], "Synthetic"); + } + + #[test] + fn iam_delete_role_identifies_type_without_synthesizing() { + let schema_validator = SchemaValidator::default(); + let request = request("iam", "DeleteRole", serde_json::json!({"RoleName": "Synthetic"})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationDelete); + assert_eq!(classification.candidates, ["AWS::IAM::Role"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn lambda_create_function_synthesizes_all_supplied_scalar_properties() { + let request = + request("lambda", "CreateFunction", serde_json::json!({"FunctionName": "Synthetic", "MemorySize": 128})); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::Lambda::Function"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedCreate)); + assert_eq!(synthesis.diagnostic_properties, Some(BTreeSet::from(["FunctionName".into(), "MemorySize".into()]))); + assert_eq!(document["Resources"]["Resource"]["Properties"]["FunctionName"], "Synthetic"); + assert_eq!(document["Resources"]["Resource"]["Properties"]["MemorySize"], 128); + } + + #[test] + fn lambda_update_function_configuration_maps_all_supplied_mutable_properties() { + let request = request( + "lambda", + "UpdateFunctionConfiguration", + serde_json::json!({"FunctionName": "Synthetic", "MemorySize": 128}), + ); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationUpdate); + assert_eq!(classification.candidates, ["AWS::Lambda::Function"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedUpdate)); + assert_eq!(document["Resources"]["Resource"]["Properties"], serde_json::json!({"MemorySize": 128})); + assert_eq!(synthesis.diagnostic_properties, Some(BTreeSet::from(["MemorySize".into()]))); + } + + #[test] + fn lambda_delete_function_identifies_type_without_synthesizing() { + let schema_validator = SchemaValidator::default(); + let request = request("lambda", "DeleteFunction", serde_json::json!({"FunctionName": "Synthetic"})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationDelete); + assert_eq!(classification.candidates, ["AWS::Lambda::Function"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn sns_create_topic_synthesizes_with_explicit_mappings() { + let request = request("sns", "CreateTopic", serde_json::json!({"Name": "Synthetic", "Tags": {"Team": "CLI"}})); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::SNS::Topic"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedCreate)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["TopicName"], "Synthetic"); + } + + #[test] + fn sns_delete_topic_identifies_type_without_synthesizing() { + let schema_validator = SchemaValidator::default(); + let request = request("sns", "DeleteTopic", serde_json::json!({"TopicArn": "arn:aws:sns:us-east-1:123:Topic"})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationDelete); + assert_eq!(classification.candidates, ["AWS::SNS::Topic"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn sqs_create_queue_synthesizes_with_explicit_mappings() { + let request = + request("sqs", "CreateQueue", serde_json::json!({"QueueName": "Synthetic", "tags": {"Team": "CLI"}})); + let (classification, synthesis, document) = synthesized_json(&request); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::SQS::Queue"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::SynthesizedCreate)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["QueueName"], "Synthetic"); + } + + #[test] + fn sqs_delete_queue_identifies_type_without_synthesizing() { + let schema_validator = SchemaValidator::default(); + let request = + request("sqs", "DeleteQueue", serde_json::json!({"QueueUrl": "https://sqs.us-east-1.amazonaws.com/123/Q"})); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationDelete); + assert_eq!(classification.candidates, ["AWS::SQS::Queue"]); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + #[test] + fn java_sdk_service_name_casing_resolves_adapters() { + let schema_validator = SchemaValidator::default(); + for (service, operation, expected_type) in [ + ("S3", "CreateBucket", "AWS::S3::Bucket"), + ("DynamoDb", "CreateTable", "AWS::DynamoDB::Table"), + ("Iam", "CreateRole", "AWS::IAM::Role"), + ("Lambda", "CreateFunction", "AWS::Lambda::Function"), + ("Sns", "CreateTopic", "AWS::SNS::Topic"), + ("Sqs", "CreateQueue", "AWS::SQS::Queue"), + ] { + let req = request(service, operation, serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert_eq!( + classification.candidates, + [expected_type], + "Java SDK casing {service}:{operation} should resolve to {expected_type}" + ); + } + } + #[test] + fn template_body_is_accepted_only_for_cloudformation_operations() { + let schema_validator = SchemaValidator::default(); + let template = br#"{"Resources":{}}"#.to_vec(); + + let mut cfn_request = request("cloudformation", "CreateChangeSet", serde_json::json!({})); + cfn_request.parameters.insert("TemplateBody".into(), AwsApiValue::Bytes { value: template.clone() }); + let classification = classify_operation(&cfn_request, &schema_validator).expect("classification succeeds"); + let synthesis = + synthesize_request(&cfn_request, &classification, &schema_validator).expect("synthesis succeeds"); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::TemplateBody)); + assert_eq!(synthesis.template, Some(template.clone())); + + let mut s3_request = request("s3", "PutObject", serde_json::json!({})); + s3_request.parameters.insert("TemplateBody".into(), AwsApiValue::Bytes { value: template.clone() }); + let classification = classify_operation(&s3_request, &schema_validator).expect("classification succeeds"); + let synthesis = + synthesize_request(&s3_request, &classification, &schema_validator).expect("synthesis succeeds"); + assert_ne!(synthesis.source, Some(AwsApiTemplateSource::TemplateBody)); + } + + #[test] + fn template_url_skip_only_for_cloudformation_operations() { + let schema_validator = SchemaValidator::default(); + let cfn_request = request( + "cloudformation", + "CreateStack", + serde_json::json!({"TemplateURL": "https://example.com/template.json"}), + ); + let classification = classify_operation(&cfn_request, &schema_validator).expect("classification succeeds"); + let synthesis = + synthesize_request(&cfn_request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + assert!(synthesis.reason.contains("unavailable")); + } + + #[test] + fn all_closed_template_body_operations_are_accepted() { + let schema_validator = SchemaValidator::default(); + let template = br#"{"Resources":{}}"#.to_vec(); + for (service, operation) in TEMPLATE_BODY_OPERATIONS { + let mut req = request(service, operation, serde_json::json!({})); + req.parameters.insert("TemplateBody".into(), AwsApiValue::Bytes { value: template.clone() }); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert_eq!( + synthesis.source, + Some(AwsApiTemplateSource::TemplateBody), + "{service}:{operation} should accept TemplateBody" + ); + } + } + #[test] + fn cloud_control_create_resource_wraps_desired_state() { + let known = request( + "cloudcontrol", + "CreateResource", + serde_json::json!({"TypeName": "AWS::SNS::Topic", "DesiredState": "{\"TopicName\":\"Synthetic\"}"}), + ); + let (classification, synthesis, document) = synthesized_json(&known); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::SNS::Topic"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::CloudControlDesiredState)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["TopicName"], "Synthetic"); + } + + #[test] + fn cloud_control_with_signing_prefix_cloudcontrolapi() { + let parameters: HashMap = serde_json::json!({ + "TypeName": "AWS::SNS::Topic", + "DesiredState": "{\"TopicName\":\"Synthetic\"}" + }) + .as_object() + .unwrap() + .iter() + .map(|(k, v)| (k.clone(), AwsApiValue::from_json(v.clone()))) + .collect(); + let req = + AwsApiRequest::new("cloudcontrol", "CreateResource", parameters).with_service_prefix("cloudcontrolapi"); + let (classification, synthesis, document) = synthesized_json(&req); + assert_eq!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + assert_eq!(classification.candidates, ["AWS::SNS::Topic"]); + assert_eq!(synthesis.source, Some(AwsApiTemplateSource::CloudControlDesiredState)); + assert_eq!(document["Resources"]["Resource"]["Properties"]["TopicName"], "Synthetic"); + } + + #[test] + fn cloud_control_rejects_unknown_type_name() { + let schema_validator = SchemaValidator::default(); + let unknown = request( + "cloudcontrol", + "CreateResource", + serde_json::json!({"TypeName": "AWS::Unknown::Type", "DesiredState": "{}"}), + ); + let classification = classify_operation(&unknown, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&unknown, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + assert!(synthesis.reason.contains("known CloudFormation TypeName")); + } + + #[test] + fn cloud_control_update_resource_reports_type_but_does_not_synthesize() { + let schema_validator = SchemaValidator::default(); + let update = request( + "cloudcontrol", + "UpdateResource", + serde_json::json!({"TypeName": "AWS::SNS::Topic", "PatchDocument": "[{\"op\":\"replace\"}]"}), + ); + let classification = classify_operation(&update, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::UnmappedMutation); + assert_eq!(classification.candidates, ["AWS::SNS::Topic"]); + let synthesis = synthesize_request(&update, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + assert!(synthesis.reason.contains("PatchDocument")); + assert_eq!(synthesis.resource_types, ["AWS::SNS::Topic"]); + } + #[test] + fn explicit_readonly_and_http_get_are_authoritative_read_signals() { + let schema_validator = SchemaValidator::default(); + let mut explicitly_readonly = request("test", "CreateThing", serde_json::json!({})); + explicitly_readonly.is_read_only = Some(true); + assert_eq!( + classify_operation(&explicitly_readonly, &schema_validator).expect("classification succeeds").kind, + AwsApiOperationKind::ReadOnly + ); + let mut get_request = request("test", "FrobnicateThing", serde_json::json!({})); + get_request.http_method = Some("GET".into()); + assert_eq!( + classify_operation(&get_request, &schema_validator).expect("classification succeeds").kind, + AwsApiOperationKind::ReadOnly + ); + } + + #[test] + fn data_plane_verbs_are_classified_correctly() { + let schema_validator = SchemaValidator::default(); + let lambda_invoke = request("lambda", "Invoke", serde_json::json!({})); + assert_eq!( + classify_operation(&lambda_invoke, &schema_validator).expect("classification succeeds").kind, + AwsApiOperationKind::DataPlaneMutation + ); + } + #[test] + fn ecs_run_task_never_maps_to_resource() { + let schema_validator = SchemaValidator::default(); + let req = request("ecs", "RunTask", serde_json::json!({"TaskDefinition": "my-task"})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert!(classification.candidates.is_empty(), "ecs:RunTask must not map to any resource type"); + assert_ne!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn ec2_start_instances_never_maps_to_resource() { + let schema_validator = SchemaValidator::default(); + let req = request("ec2", "StartInstances", serde_json::json!({"InstanceIds": ["i-12345"]})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert!(classification.candidates.is_empty(), "ec2:StartInstances must not map to any resource type"); + assert_ne!(classification.kind, AwsApiOperationKind::CloudFormationCreate); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none()); + } + + #[test] + fn iot_start_thing_registration_task_never_maps_to_resource() { + let schema_validator = SchemaValidator::default(); + let req = request("iot", "StartThingRegistrationTask", serde_json::json!({"TemplateBody": "{}"})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert!( + classification.candidates.is_empty(), + "iot:StartThingRegistrationTask must not map to any resource type" + ); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert_ne!(synthesis.source, Some(AwsApiTemplateSource::TemplateBody)); + } + + #[test] + fn wrong_service_template_body_is_not_treated_as_cfn_template() { + let schema_validator = SchemaValidator::default(); + let template = br#"{"Resources":{}}"#.to_vec(); + for service in ["s3", "lambda", "iot", "dynamodb"] { + let mut req = request(service, "SomeOperation", serde_json::json!({})); + req.parameters.insert("TemplateBody".into(), AwsApiValue::Bytes { value: template.clone() }); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert_ne!( + synthesis.source, + Some(AwsApiTemplateSource::TemplateBody), + "{service}:SomeOperation should not treat TemplateBody as CFN template" + ); + } + } + + #[test] + fn wrong_service_type_name_desired_state_is_not_wrapped() { + let schema_validator = SchemaValidator::default(); + let req = request( + "s3", + "CreateResource", + serde_json::json!({"TypeName": "AWS::SNS::Topic", "DesiredState": "{\"TopicName\":\"Synthetic\"}"}), + ); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert_ne!(synthesis.source, Some(AwsApiTemplateSource::CloudControlDesiredState)); + } + + #[test] + fn near_match_operation_names_never_map_or_synthesize() { + let schema_validator = SchemaValidator::default(); + for (service, operation) in [ + ("s3", "CreateBuckets"), + ("s3", "createBucket"), + ("dynamodb", "CreateTables"), + ("lambda", "CreateFunctions"), + ("lambda", "UpdateFunctionConfigurations"), + ] { + let req = request(service, operation, serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert!( + classification.candidates.is_empty(), + "{service}:{operation} near-match must not resolve to any adapter" + ); + } + } + #[test] + fn incompatible_property_value_skips_synthesis() { + let schema_validator = SchemaValidator::default(); + let request = request( + "iam", + "CreateRole", + serde_json::json!({ + "RoleName": "Synthetic", + "AssumeRolePolicyDocument": "{}", + "Tags": {"Key": 42} + }), + ); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&request, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none(), "incompatible value must skip synthesis"); + assert!( + synthesis.reason.contains("cannot be represented"), + "reason must explain the type mismatch: {}", + synthesis.reason + ); + } + + #[test] + fn high_level_api_validates_exact_template_and_reports_skips() { + let engine = NoopEngine::default(); + let schema_validator = SchemaValidator::default(); + let mut exact = request("cloudformation", "CreateChangeSet", serde_json::json!({})); + exact.parameters.insert("TemplateBody".into(), AwsApiValue::Bytes { value: br#"{"Resources":{}}"#.to_vec() }); + let validation = validate_aws_api_request(&engine, &schema_validator, &exact, ValidateConfig::default()) + .expect("validation succeeds"); + assert_eq!(validation.status, AwsApiRequestValidationStatus::Validated); + assert_eq!(validation.template_source, Some(AwsApiTemplateSource::TemplateBody)); + assert!(validation.report.is_some()); + assert_eq!( + validation.template, + Some(br#"{"Resources":{}}"#.to_vec()), + "exact TemplateBody bytes must be preserved without reserializing" + ); + + let read = request("iam", "GetRole", serde_json::json!({"RoleName": "Synthetic"})); + let validation = validate_aws_api_request(&engine, &schema_validator, &read, ValidateConfig::default()) + .expect("classification succeeds"); + assert_eq!(validation.status, AwsApiRequestValidationStatus::Skipped); + assert_eq!(validation.operation_kind, AwsApiOperationKind::ReadOnly); + assert!(validation.report.is_none()); + assert_eq!(validation.template, None, "skipped requests must have template=None"); + } + + #[test] + fn partial_update_scoping_keeps_report_counts_consistent() { + let engine = NoopEngine::default(); + let schema_validator = SchemaValidator::default(); + let update = request( + "lambda", + "UpdateFunctionConfiguration", + serde_json::json!({"FunctionName": "Synthetic", "MemorySize": 0}), + ); + let validation = validate_aws_api_request(&engine, &schema_validator, &update, ValidateConfig::default()) + .expect("validation succeeds"); + let report = validation.report.expect("update is validated"); + assert!( + report + .diagnostics + .iter() + .all(|diagnostic| diagnostic.property_path.as_deref().is_some_and(|path| path.contains("MemorySize"))) + ); + let counts = &report.metadata.counts; + assert_eq!( + report.diagnostics.len() as u32, + counts.fatal + counts.errors + counts.warnings + counts.informational + counts.debug + ); + } + + #[test] + fn request_parameters_are_not_mutated() { + let parameters = HashMap::from([ + ("TableName".into(), value(serde_json::json!("Synthetic"))), + ("KeySchema".into(), value(serde_json::json!([{"AttributeName": "id", "KeyType": "HASH"}]))), + ("AttributeDefinitions".into(), value(serde_json::json!([{"AttributeName": "id", "AttributeType": "S"}]))), + ]); + let original = parameters.clone(); + let request = AwsApiRequest::new("dynamodb", "CreateTable", parameters); + let schema_validator = SchemaValidator::default(); + let classification = classify_operation(&request, &schema_validator).expect("classification succeeds"); + let _ = synthesize_request(&request, &classification, &schema_validator); + assert_eq!(request.parameters, original); + } + + #[test] + fn json_conversion_rejects_non_json_values_without_coercion() { + assert!(AwsApiValue::Bytes { value: vec![1, 2] }.to_json().is_err()); + assert!(AwsApiValue::Number { value: f64::NAN }.to_json().is_err()); + assert!(AwsApiValue::Unsupported { type_name: "timestamp".into() }.to_json().is_err()); + } + + #[test] + fn operation_words_preserve_acronyms_for_verb_classification() { + assert_eq!(operation_words("BatchCreateDB2Cluster"), ["Batch", "Create", "DB", "2", "Cluster"]); + assert_eq!(effective_verb(&operation_words("BatchCreateDB2Cluster")), "Create"); + } + + #[test] + fn normalize_service_changes_ascii_case_only() { + assert_eq!(normalize_service("s3"), "s3"); + assert_eq!(normalize_service("S3"), "s3"); + assert_eq!(normalize_service("DynamoDb"), "dynamodb"); + assert_eq!(normalize_service("dynamodb"), "dynamodb"); + assert_eq!(normalize_service("cloud-control"), "cloud-control"); + assert_eq!(normalize_service("CloudControl"), "cloudcontrol"); + assert_eq!(normalize_service("cloudcontrolapi"), "cloudcontrolapi"); + } + + #[test] + fn conflicting_service_prefix_does_not_map_adapter() { + let schema_validator = SchemaValidator::default(); + let parameters: HashMap = serde_json::json!({"Bucket": "test"}) + .as_object() + .unwrap() + .iter() + .map(|(k, v)| (k.clone(), AwsApiValue::from_json(v.clone()))) + .collect(); + let req = AwsApiRequest::new("ecs", "CreateBucket", parameters).with_service_prefix("s3"); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert!( + classification.candidates.is_empty(), + "service_name=ecs with service_prefix=s3 must not map CreateBucket" + ); + + let punctuated = request("s-3", "CreateBucket", serde_json::json!({"Bucket": "test"})); + let classification = classify_operation(&punctuated, &schema_validator).expect("classification succeeds"); + assert!(classification.candidates.is_empty(), "punctuated service names must not map adapters"); + } + + #[test] + fn conflicting_service_prefix_does_not_validate_template_body() { + let schema_validator = SchemaValidator::default(); + let template = br#"{"Resources":{}}"#.to_vec(); + let parameters: HashMap = + [("TemplateBody".to_string(), AwsApiValue::Bytes { value: template })].into_iter().collect(); + let req = AwsApiRequest::new("iot", "CreateStack", parameters).with_service_prefix("cloudformation"); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert_ne!( + synthesis.source, + Some(AwsApiTemplateSource::TemplateBody), + "service_name=iot with service_prefix=cloudformation must not validate TemplateBody" + ); + } + + #[test] + fn arbitrary_cloudcontrol_operation_with_valid_type_name_has_no_candidates() { + let schema_validator = SchemaValidator::default(); + let req = request("cloudcontrol", "ListResources", serde_json::json!({"TypeName": "AWS::SNS::Topic"})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert!( + classification.candidates.is_empty(), + "arbitrary cloudcontrol operations must not produce resource_types even with valid TypeName" + ); + } + + #[test] + fn lambda_create_partial_scopes_to_mapped_properties_only() { + let engine = NoopEngine::default(); + let schema_validator = SchemaValidator::default(); + let req = request("lambda", "CreateFunction", serde_json::json!({"MemorySize": 0})); + let validation = validate_aws_api_request(&engine, &schema_validator, &req, ValidateConfig::default()) + .expect("validation succeeds"); + assert_eq!(validation.status, AwsApiRequestValidationStatus::Validated); + assert_eq!(validation.template_source, Some(AwsApiTemplateSource::SynthesizedCreate)); + let report = validation.report.expect("create is validated"); + for diagnostic in &report.diagnostics { + assert!( + diagnostic.property_path.as_deref().is_some_and(|p| p.contains("MemorySize")), + "diagnostic must be scoped to MemorySize, got: {:?}", + diagnostic.property_path + ); + } + let counts = &report.metadata.counts; + assert_eq!( + report.diagnostics.len() as u32, + counts.fatal + counts.errors + counts.warnings + counts.informational + counts.debug, + ); + // The template field carries the synthesized JSON used for validation. + let template_bytes = validation.template.expect("validated requests carry template bytes"); + let template_json: serde_json::Value = + serde_json::from_slice(&template_bytes).expect("template must be valid JSON"); + assert_eq!(template_json["Resources"]["Resource"]["Type"], "AWS::Lambda::Function"); + assert_eq!(template_json["Resources"]["Resource"]["Properties"]["MemorySize"], 0); + } + + #[test] + fn template_body_create_operations_have_cloud_formation_create_kind() { + let schema_validator = SchemaValidator::default(); + for operation in ["CreateChangeSet", "CreateStack", "CreateStackSet"] { + let req = request("cloudformation", operation, serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert_eq!( + classification.kind, + AwsApiOperationKind::CloudFormationCreate, + "cloudformation:{operation} must be CloudFormationCreate" + ); + } + } + + #[test] + fn template_body_update_operations_have_cloud_formation_update_kind() { + let schema_validator = SchemaValidator::default(); + for operation in ["UpdateStack", "UpdateStackSet"] { + let req = request("cloudformation", operation, serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert_eq!( + classification.kind, + AwsApiOperationKind::CloudFormationUpdate, + "cloudformation:{operation} must be CloudFormationUpdate" + ); + } + } + + #[test] + fn template_body_readonly_operations_have_readonly_kind() { + let schema_validator = SchemaValidator::default(); + for operation in ["EstimateTemplateCost", "GetTemplateSummary", "ValidateTemplate"] { + let req = request("cloudformation", operation, serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert_eq!( + classification.kind, + AwsApiOperationKind::ReadOnly, + "cloudformation:{operation} must be ReadOnly" + ); + } + } + + #[test] + fn template_body_readonly_operations_still_validate_payload() { + let engine = NoopEngine::default(); + let schema_validator = SchemaValidator::default(); + let template = br#"{"Resources":{}}"#.to_vec(); + for operation in ["EstimateTemplateCost", "GetTemplateSummary", "ValidateTemplate"] { + let parameters: HashMap = + [("TemplateBody".to_string(), AwsApiValue::Bytes { value: template.clone() })].into_iter().collect(); + let req = AwsApiRequest::new("cloudformation", operation, parameters); + let validation = validate_aws_api_request(&engine, &schema_validator, &req, ValidateConfig::default()) + .expect("validation succeeds"); + assert_eq!( + validation.status, + AwsApiRequestValidationStatus::Validated, + "cloudformation:{operation} with TemplateBody must still validate" + ); + assert_eq!(validation.template_source, Some(AwsApiTemplateSource::TemplateBody)); + } + } + + #[test] + fn unknown_cloudformation_verbs_remain_unmapped() { + let schema_validator = SchemaValidator::default(); + let req = request("cloudformation", "DeleteChangeSet", serde_json::json!({})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + assert_eq!(classification.kind, AwsApiOperationKind::UnmappedMutation); + assert!(classification.candidates.is_empty()); + } + + #[test] + fn unmapped_parameter_skips_synthesis_with_reason() { + let schema_validator = SchemaValidator::default(); + let req = request("s3", "CreateBucket", serde_json::json!({"Bucket": "test-bucket", "UnknownParam": "value"})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_none(), "unmapped parameter must skip synthesis"); + assert!( + synthesis.reason.contains("UnknownParam") && synthesis.reason.contains("no mapping"), + "reason must name the unmapped parameter: {}", + synthesis.reason + ); + } + + #[test] + fn ignored_input_does_not_block_synthesis() { + let schema_validator = SchemaValidator::default(); + let schema = schema_validator.resource_schema_metadata("AWS::S3::Bucket").expect("S3 bucket schema must exist"); + let adapter = OperationAdapter { + service: "s3".into(), + operation: "CreateBucket".into(), + phase: AdapterPhase::Create, + cfn_type: "AWS::S3::Bucket".into(), + mappings: vec![mapping("Bucket", "BucketName")], + ignored_inputs: vec!["ClientToken".into()], + }; + let parameters: HashMap = [ + ("Bucket".into(), AwsApiValue::String { value: "test".into() }), + ("ClientToken".into(), AwsApiValue::String { value: "idempotent-token".into() }), + ] + .into_iter() + .collect(); + let result = map_adapter_properties(¶meters, &schema, &adapter).expect("mapping must succeed"); + match result { + AdapterMappingResult::Mapped(properties) => { + assert_eq!(properties.len(), 1); + assert_eq!(properties["BucketName"], serde_json::json!("test")); + } + AdapterMappingResult::Skip(reason) => { + panic!("ignored input should not skip synthesis: {reason}"); + } + } + } + + #[test] + fn update_adapter_ignores_primary_identifier_parameters() { + let schema_validator = SchemaValidator::default(); + let schema = schema_validator + .resource_schema_metadata("AWS::Lambda::Function") + .expect("Lambda function schema must exist"); + let adapter = OperationAdapter { + service: "lambda".into(), + operation: "UpdateFunctionConfiguration".into(), + phase: AdapterPhase::Update, + cfn_type: "AWS::Lambda::Function".into(), + mappings: vec![mapping("MemorySize", "MemorySize")], + ignored_inputs: Vec::new(), + }; + // FunctionName is a primary identifier for AWS::Lambda::Function + let parameters: HashMap = [ + ("MemorySize".into(), AwsApiValue::Integer { value: 256 }), + ("FunctionName".into(), AwsApiValue::String { value: "my-func".into() }), + ] + .into_iter() + .collect(); + let result = map_adapter_properties(¶meters, &schema, &adapter).expect("mapping must succeed"); + match result { + AdapterMappingResult::Mapped(properties) => { + assert_eq!(properties.len(), 1); + assert_eq!(properties["MemorySize"], serde_json::json!(256)); + } + AdapterMappingResult::Skip(reason) => { + panic!("primary identifier on update must be ignored: {reason}"); + } + } + } + + #[test] + fn all_mapped_parameters_produce_successful_synthesis() { + let schema_validator = SchemaValidator::default(); + let req = request("s3", "CreateBucket", serde_json::json!({"Bucket": "all-mapped"})); + let classification = classify_operation(&req, &schema_validator).expect("classification succeeds"); + let synthesis = synthesize_request(&req, &classification, &schema_validator).expect("synthesis succeeds"); + assert!(synthesis.template.is_some(), "all-mapped parameters must synthesize"); + } + + #[test] + fn catalog_ignored_inputs_deserialize_from_missing_field() { + let json = br#"{ + "format_version": 1, + "adapters": [ + {"service":"test","operation":"Create","phase":"create","cfn_type":"AWS::Test::Type","mappings":[]} + ] + }"#; + let registry = parse_adapter_registry(json).expect("catalog without ignored_inputs must parse"); + let adapter = registry.get(&("test".to_string(), "Create".to_string())).expect("adapter must exist"); + assert!(adapter.ignored_inputs.is_empty(), "missing field defaults to empty"); + } + + #[test] + fn catalog_ignored_inputs_deserialize_from_explicit_field() { + let json = br#"{ + "format_version": 1, + "adapters": [ + {"service":"test","operation":"Create","phase":"create","cfn_type":"AWS::Test::Type", + "mappings":[],"ignored_inputs":["ClientToken","DryRun"]} + ] + }"#; + let registry = parse_adapter_registry(json).expect("catalog with ignored_inputs must parse"); + let adapter = registry.get(&("test".to_string(), "Create".to_string())).expect("adapter must exist"); + assert_eq!(adapter.ignored_inputs, vec!["ClientToken", "DryRun"]); + } +} diff --git a/src/validation-engine/src/lib.rs b/src/validation-engine/src/lib.rs index 074f1f24..2b899ca6 100644 --- a/src/validation-engine/src/lib.rs +++ b/src/validation-engine/src/lib.rs @@ -1,10 +1,15 @@ #[cfg(feature = "uniffi-bindings")] uniffi::setup_scaffolding!(); +pub mod aws_api; pub mod engine; pub mod guard; pub(crate) mod step_functions; +pub use aws_api::{ + AwsApiOperationKind, AwsApiRequest, AwsApiRequestContext, AwsApiRequestValidation, AwsApiRequestValidationStatus, + AwsApiTemplateSource, AwsApiValue, validate_aws_api_request, validate_aws_api_request_with_path, +}; pub use engine::{ DIAGNOSTIC_SOURCE_PATH_FIELD, EngineConfig, EngineType, ExternalRuleSource, ValidateConfig, ValidationEngine, ValidationError, build_rule_list, catch_panics, extract_diagnostics, make_resource_diagnostic, diff --git a/src/validation-engine/uniffi.toml b/src/validation-engine/uniffi.toml index dee40e93..6aa4f76f 100644 --- a/src/validation-engine/uniffi.toml +++ b/src/validation-engine/uniffi.toml @@ -1,6 +1,7 @@ [bindings.kotlin] package_name = "software.amazon.cloudformation.validate.engine" generate_immutable_records = true +disable_java_cleaner = true [bindings.kotlin.external_packages] rules = "software.amazon.cloudformation.validate.rules"