@aws-sdk/client-kinesis 3.231.0 → 3.232.0

package/dist-cjs/endpoint/ruleset.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ruleSet = void 0;
 exports.ruleSet = {
-    version: "1.0",
+    version: "1.3",
     parameters: {
         Region: {
             builtIn: "AWS::Region",
-            required: false,
+            required: true,
             documentation: "The AWS region used to dispatch the request.",
             type: "String",
         },
@@ -30,6 +30,21 @@ exports.ruleSet = {
             documentation: "Override the endpoint used to send this request",
             type: "String",
         },
+        StreamARN: {
+            required: false,
+            documentation: "The ARN of the Kinesis stream",
+            type: "String",
+        },
+        OperationType: {
+            required: false,
+            documentation: "Internal parameter to distinguish between Control/Data plane API and accordingly generate control/data plane endpoint",
+            type: "String",
+        },
+        ConsumerARN: {
+            required: false,
+            documentation: "The ARN of the Kinesis consumer",
+            type: "String",
+        },
     },
     rules: [
         {
@@ -52,18 +67,1067 @@ exports.ruleSet = {
                             fn: "isSet",
                             argv: [
                                 {
-                                    ref: "Endpoint",
+                                    ref: "StreamARN",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "not",
+                            argv: [
+                                {
+                                    fn: "isSet",
+                                    argv: [
+                                        {
+                                            ref: "Endpoint",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            fn: "not",
+                            argv: [
+                                {
+                                    fn: "stringEquals",
+                                    argv: [
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "name",
+                                            ],
+                                        },
+                                        "aws-iso",
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            fn: "not",
+                            argv: [
+                                {
+                                    fn: "stringEquals",
+                                    argv: [
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "name",
+                                            ],
+                                        },
+                                        "aws-iso-b",
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "aws.parseArn",
+                                    argv: [
+                                        {
+                                            ref: "StreamARN",
+                                        },
+                                    ],
+                                    assign: "arn",
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    type: "tree",
+                                    rules: [
+                                        {
+                                            conditions: [
+                                                {
+                                                    fn: "isValidHostLabel",
+                                                    argv: [
+                                                        {
+                                                            fn: "getAttr",
+                                                            argv: [
+                                                                {
+                                                                    ref: "arn",
+                                                                },
+                                                                "accountId",
+                                                            ],
+                                                        },
+                                                        false,
+                                                    ],
+                                                },
+                                            ],
+                                            type: "tree",
+                                            rules: [
+                                                {
+                                                    conditions: [],
+                                                    type: "tree",
+                                                    rules: [
+                                                        {
+                                                            conditions: [
+                                                                {
+                                                                    fn: "isValidHostLabel",
+                                                                    argv: [
+                                                                        {
+                                                                            fn: "getAttr",
+                                                                            argv: [
+                                                                                {
+                                                                                    ref: "arn",
+                                                                                },
+                                                                                "region",
+                                                                            ],
+                                                                        },
+                                                                        false,
+                                                                    ],
+                                                                },
+                                                            ],
+                                                            type: "tree",
+                                                            rules: [
+                                                                {
+                                                                    conditions: [],
+                                                                    type: "tree",
+                                                                    rules: [
+                                                                        {
+                                                                            conditions: [
+                                                                                {
+                                                                                    fn: "stringEquals",
+                                                                                    argv: [
+                                                                                        {
+                                                                                            fn: "getAttr",
+                                                                                            argv: [
+                                                                                                {
+                                                                                                    ref: "arn",
+                                                                                                },
+                                                                                                "service",
+                                                                                            ],
+                                                                                        },
+                                                                                        "kinesis",
+                                                                                    ],
+                                                                                },
+                                                                            ],
+                                                                            type: "tree",
+                                                                            rules: [
+                                                                                {
+                                                                                    conditions: [],
+                                                                                    type: "tree",
+                                                                                    rules: [
+                                                                                        {
+                                                                                            conditions: [
+                                                                                                {
+                                                                                                    fn: "getAttr",
+                                                                                                    argv: [
+                                                                                                        {
+                                                                                                            ref: "arn",
+                                                                                                        },
+                                                                                                        "resourceId[0]",
+                                                                                                    ],
+                                                                                                    assign: "arnType",
+                                                                                                },
+                                                                                                {
+                                                                                                    fn: "not",
+                                                                                                    argv: [
+                                                                                                        {
+                                                                                                            fn: "stringEquals",
+                                                                                                            argv: [
+                                                                                                                {
+                                                                                                                    ref: "arnType",
+                                                                                                                },
+                                                                                                                "",
+                                                                                                            ],
+                                                                                                        },
+                                                                                                    ],
+                                                                                                },
+                                                                                            ],
+                                                                                            type: "tree",
+                                                                                            rules: [
+                                                                                                {
+                                                                                                    conditions: [],
+                                                                                                    type: "tree",
+                                                                                                    rules: [
+                                                                                                        {
+                                                                                                            conditions: [
+                                                                                                                {
+                                                                                                                    fn: "stringEquals",
+                                                                                                                    argv: [
+                                                                                                                        {
+                                                                                                                            ref: "arnType",
+                                                                                                                        },
+                                                                                                                        "stream",
+                                                                                                                    ],
+                                                                                                                },
+                                                                                                            ],
+                                                                                                            type: "tree",
+                                                                                                            rules: [
+                                                                                                                {
+                                                                                                                    conditions: [],
+                                                                                                                    type: "tree",
+                                                                                                                    rules: [
+                                                                                                                        {
+                                                                                                                            conditions: [
+                                                                                                                                {
+                                                                                                                                    fn: "stringEquals",
+                                                                                                                                    argv: [
+                                                                                                                                        {
+                                                                                                                                            fn: "getAttr",
+                                                                                                                                            argv: [
+                                                                                                                                                {
+                                                                                                                                                    ref: "PartitionResult",
+                                                                                                                                                },
+                                                                                                                                                "name",
+                                                                                                                                            ],
+                                                                                                                                        },
+                                                                                                                                        "{arn#partition}",
+                                                                                                                                    ],
+                                                                                                                                },
+                                                                                                                            ],
+                                                                                                                            type: "tree",
+                                                                                                                            rules: [
+                                                                                                                                {
+                                                                                                                                    conditions: [],
+                                                                                                                                    type: "tree",
+                                                                                                                                    rules: [
+                                                                                                                                        {
+                                                                                                                                            conditions: [
+                                                                                                                                                {
+                                                                                                                                                    fn: "isSet",
+                                                                                                                                                    argv: [
+                                                                                                                                                        {
+                                                                                                                                                            ref: "OperationType",
+                                                                                                                                                        },
+                                                                                                                                                    ],
+                                                                                                                                                },
+                                                                                                                                            ],
+                                                                                                                                            type: "tree",
+                                                                                                                                            rules: [
+                                                                                                                                                {
+                                                                                                                                                    conditions: [],
+                                                                                                                                                    type: "tree",
+                                                                                                                                                    rules: [
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseFIPS",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseDualStack",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                            type: "tree",
+                                                                                                                                                            rules: [
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [
+                                                                                                                                                                        {
+                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                            argv: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                    argv: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                        },
+                                                                                                                                                                                        "supportsFIPS",
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                true,
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                    type: "tree",
+                                                                                                                                                                    rules: [
+                                                                                                                                                                        {
+                                                                                                                                                                            conditions: [],
+                                                                                                                                                                            type: "tree",
+                                                                                                                                                                            rules: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    conditions: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                                            argv: [
+                                                                                                                                                                                                {
+                                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                                    argv: [
+                                                                                                                                                                                                        {
+                                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                                        },
+                                                                                                                                                                                                        "supportsDualStack",
+                                                                                                                                                                                                    ],
+                                                                                                                                                                                                },
+                                                                                                                                                                                                true,
+                                                                                                                                                                                            ],
+                                                                                                                                                                                        },
+                                                                                                                                                                                    ],
+                                                                                                                                                                                    type: "tree",
+                                                                                                                                                                                    rules: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            conditions: [],
+                                                                                                                                                                                            endpoint: {
+                                                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                                                                                                                                                                                properties: {},
+                                                                                                                                                                                                headers: {},
+                                                                                                                                                                                            },
+                                                                                                                                                                                            type: "endpoint",
+                                                                                                                                                                                        },
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                {
+                                                                                                                                                                                    conditions: [],
+                                                                                                                                                                                    error: "DualStack is enabled, but this partition does not support DualStack.",
+                                                                                                                                                                                    type: "error",
+                                                                                                                                                                                },
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [],
+                                                                                                                                                                    error: "FIPS is enabled, but this partition does not support FIPS.",
+                                                                                                                                                                    type: "error",
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                        },
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseFIPS",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                            type: "tree",
+                                                                                                                                                            rules: [
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [
+                                                                                                                                                                        {
+                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                            argv: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                    argv: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                        },
+                                                                                                                                                                                        "supportsFIPS",
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                true,
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                    type: "tree",
+                                                                                                                                                                    rules: [
+                                                                                                                                                                        {
+                                                                                                                                                                            conditions: [],
+                                                                                                                                                                            endpoint: {
+                                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                                                                                                                                                                properties: {},
+                                                                                                                                                                                headers: {},
+                                                                                                                                                                            },
+                                                                                                                                                                            type: "endpoint",
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [],
+                                                                                                                                                                    error: "FIPS is enabled but this partition does not support FIPS",
+                                                                                                                                                                    type: "error",
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                        },
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseDualStack",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                            type: "tree",
+                                                                                                                                                            rules: [
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [
+                                                                                                                                                                        {
+                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                            argv: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                    argv: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                        },
+                                                                                                                                                                                        "supportsDualStack",
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                true,
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                    type: "tree",
+                                                                                                                                                                    rules: [
+                                                                                                                                                                        {
+                                                                                                                                                                            conditions: [],
+                                                                                                                                                                            endpoint: {
+                                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                                                                                                                                                                properties: {},
+                                                                                                                                                                                headers: {},
+                                                                                                                                                                            },
+                                                                                                                                                                            type: "endpoint",
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [],
+                                                                                                                                                                    error: "DualStack is enabled but this partition does not support DualStack",
+                                                                                                                                                                    type: "error",
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                        },
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [],
+                                                                                                                                                            endpoint: {
+                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dnsSuffix}",
+                                                                                                                                                                properties: {},
+                                                                                                                                                                headers: {},
+                                                                                                                                                            },
+                                                                                                                                                            type: "endpoint",
+                                                                                                                                                        },
+                                                                                                                                                    ],
+                                                                                                                                                },
+                                                                                                                                            ],
+                                                                                                                                        },
+                                                                                                                                        {
+                                                                                                                                            conditions: [],
+                                                                                                                                            error: "Operation Type is not set. Please contact service team for resolution.",
+                                                                                                                                            type: "error",
+                                                                                                                                        },
+                                                                                                                                    ],
+                                                                                                                                },
+                                                                                                                            ],
+                                                                                                                        },
+                                                                                                                        {
+                                                                                                                            conditions: [],
+                                                                                                                            error: "Partition: {arn#partition} from ARN doesn't match with partition name: {PartitionResult#name}.",
+                                                                                                                            type: "error",
+                                                                                                                        },
+                                                                                                                    ],
+                                                                                                                },
+                                                                                                            ],
+                                                                                                        },
+                                                                                                        {
+                                                                                                            conditions: [],
+                                                                                                            error: "Invalid ARN: Kinesis ARNs don't support `{arnType}` arn types.",
+                                                                                                            type: "error",
+                                                                                                        },
+                                                                                                    ],
+                                                                                                },
+                                                                                            ],
+                                                                                        },
+                                                                                        {
+                                                                                            conditions: [],
+                                                                                            error: "Invalid ARN: No ARN type specified",
+                                                                                            type: "error",
+                                                                                        },
+                                                                                    ],
+                                                                                },
+                                                                            ],
+                                                                        },
+                                                                        {
+                                                                            conditions: [],
+                                                                            error: "Invalid ARN: The ARN was not for the Kinesis service, found: {arn#service}.",
+                                                                            type: "error",
+                                                                        },
+                                                                    ],
+                                                                },
+                                                            ],
+                                                        },
+                                                        {
+                                                            conditions: [],
+                                                            error: "Invalid ARN: Invalid region.",
+                                                            type: "error",
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                        {
+                                            conditions: [],
+                                            error: "Invalid ARN: Invalid account id.",
+                                            type: "error",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "Invalid ARN: Failed to parse ARN.",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "ConsumerARN",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "not",
+                            argv: [
+                                {
+                                    fn: "isSet",
+                                    argv: [
+                                        {
+                                            ref: "Endpoint",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            fn: "not",
+                            argv: [
+                                {
+                                    fn: "stringEquals",
+                                    argv: [
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "name",
+                                            ],
+                                        },
+                                        "aws-iso",
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            fn: "not",
+                            argv: [
+                                {
+                                    fn: "stringEquals",
+                                    argv: [
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "name",
+                                            ],
+                                        },
+                                        "aws-iso-b",
+                                    ],
                                 },
                             ],
                         },
+                    ],
+                    type: "tree",
+                    rules: [
                         {
-                            fn: "parseURL",
+                            conditions: [
+                                {
+                                    fn: "aws.parseArn",
+                                    argv: [
+                                        {
+                                            ref: "ConsumerARN",
+                                        },
+                                    ],
+                                    assign: "arn",
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    type: "tree",
+                                    rules: [
+                                        {
+                                            conditions: [
+                                                {
+                                                    fn: "isValidHostLabel",
+                                                    argv: [
+                                                        {
+                                                            fn: "getAttr",
+                                                            argv: [
+                                                                {
+                                                                    ref: "arn",
+                                                                },
+                                                                "accountId",
+                                                            ],
+                                                        },
+                                                        false,
+                                                    ],
+                                                },
+                                            ],
+                                            type: "tree",
+                                            rules: [
+                                                {
+                                                    conditions: [],
+                                                    type: "tree",
+                                                    rules: [
+                                                        {
+                                                            conditions: [
+                                                                {
+                                                                    fn: "isValidHostLabel",
+                                                                    argv: [
+                                                                        {
+                                                                            fn: "getAttr",
+                                                                            argv: [
+                                                                                {
+                                                                                    ref: "arn",
+                                                                                },
+                                                                                "region",
+                                                                            ],
+                                                                        },
+                                                                        false,
+                                                                    ],
+                                                                },
+                                                            ],
+                                                            type: "tree",
+                                                            rules: [
+                                                                {
+                                                                    conditions: [],
+                                                                    type: "tree",
+                                                                    rules: [
+                                                                        {
+                                                                            conditions: [
+                                                                                {
+                                                                                    fn: "stringEquals",
+                                                                                    argv: [
+                                                                                        {
+                                                                                            fn: "getAttr",
+                                                                                            argv: [
+                                                                                                {
+                                                                                                    ref: "arn",
+                                                                                                },
+                                                                                                "service",
+                                                                                            ],
+                                                                                        },
+                                                                                        "kinesis",
+                                                                                    ],
+                                                                                },
+                                                                            ],
+                                                                            type: "tree",
+                                                                            rules: [
+                                                                                {
+                                                                                    conditions: [],
+                                                                                    type: "tree",
+                                                                                    rules: [
+                                                                                        {
+                                                                                            conditions: [
+                                                                                                {
+                                                                                                    fn: "getAttr",
+                                                                                                    argv: [
+                                                                                                        {
+                                                                                                            ref: "arn",
+                                                                                                        },
+                                                                                                        "resourceId[0]",
+                                                                                                    ],
+                                                                                                    assign: "arnType",
+                                                                                                },
+                                                                                                {
+                                                                                                    fn: "not",
+                                                                                                    argv: [
+                                                                                                        {
+                                                                                                            fn: "stringEquals",
+                                                                                                            argv: [
+                                                                                                                {
+                                                                                                                    ref: "arnType",
+                                                                                                                },
+                                                                                                                "",
+                                                                                                            ],
+                                                                                                        },
+                                                                                                    ],
+                                                                                                },
+                                                                                            ],
+                                                                                            type: "tree",
+                                                                                            rules: [
+                                                                                                {
+                                                                                                    conditions: [],
+                                                                                                    type: "tree",
+                                                                                                    rules: [
+                                                                                                        {
+                                                                                                            conditions: [
+                                                                                                                {
+                                                                                                                    fn: "stringEquals",
+                                                                                                                    argv: [
+                                                                                                                        {
+                                                                                                                            ref: "arnType",
+                                                                                                                        },
+                                                                                                                        "stream",
+                                                                                                                    ],
+                                                                                                                },
+                                                                                                            ],
+                                                                                                            type: "tree",
+                                                                                                            rules: [
+                                                                                                                {
+                                                                                                                    conditions: [],
+                                                                                                                    type: "tree",
+                                                                                                                    rules: [
+                                                                                                                        {
+                                                                                                                            conditions: [
+                                                                                                                                {
+                                                                                                                                    fn: "stringEquals",
+                                                                                                                                    argv: [
+                                                                                                                                        {
+                                                                                                                                            fn: "getAttr",
+                                                                                                                                            argv: [
+                                                                                                                                                {
+                                                                                                                                                    ref: "PartitionResult",
+                                                                                                                                                },
+                                                                                                                                                "name",
+                                                                                                                                            ],
+                                                                                                                                        },
+                                                                                                                                        "{arn#partition}",
+                                                                                                                                    ],
+                                                                                                                                },
+                                                                                                                            ],
+                                                                                                                            type: "tree",
+                                                                                                                            rules: [
+                                                                                                                                {
+                                                                                                                                    conditions: [],
+                                                                                                                                    type: "tree",
+                                                                                                                                    rules: [
+                                                                                                                                        {
+                                                                                                                                            conditions: [
+                                                                                                                                                {
+                                                                                                                                                    fn: "isSet",
+                                                                                                                                                    argv: [
+                                                                                                                                                        {
+                                                                                                                                                            ref: "OperationType",
+                                                                                                                                                        },
+                                                                                                                                                    ],
+                                                                                                                                                },
+                                                                                                                                            ],
+                                                                                                                                            type: "tree",
+                                                                                                                                            rules: [
+                                                                                                                                                {
+                                                                                                                                                    conditions: [],
+                                                                                                                                                    type: "tree",
+                                                                                                                                                    rules: [
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseFIPS",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseDualStack",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                            type: "tree",
+                                                                                                                                                            rules: [
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [
+                                                                                                                                                                        {
+                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                            argv: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                    argv: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                        },
+                                                                                                                                                                                        "supportsFIPS",
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                true,
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                    type: "tree",
+                                                                                                                                                                    rules: [
+                                                                                                                                                                        {
+                                                                                                                                                                            conditions: [],
+                                                                                                                                                                            type: "tree",
+                                                                                                                                                                            rules: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    conditions: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                                            argv: [
+                                                                                                                                                                                                {
+                                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                                    argv: [
+                                                                                                                                                                                                        {
+                                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                                        },
+                                                                                                                                                                                                        "supportsDualStack",
+                                                                                                                                                                                                    ],
+                                                                                                                                                                                                },
+                                                                                                                                                                                                true,
+                                                                                                                                                                                            ],
+                                                                                                                                                                                        },
+                                                                                                                                                                                    ],
+                                                                                                                                                                                    type: "tree",
+                                                                                                                                                                                    rules: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            conditions: [],
+                                                                                                                                                                                            endpoint: {
+                                                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                                                                                                                                                                                properties: {},
+                                                                                                                                                                                                headers: {},
+                                                                                                                                                                                            },
+                                                                                                                                                                                            type: "endpoint",
+                                                                                                                                                                                        },
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                {
+                                                                                                                                                                                    conditions: [],
+                                                                                                                                                                                    error: "DualStack is enabled, but this partition does not support DualStack.",
+                                                                                                                                                                                    type: "error",
+                                                                                                                                                                                },
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [],
+                                                                                                                                                                    error: "FIPS is enabled, but this partition does not support FIPS.",
+                                                                                                                                                                    type: "error",
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                        },
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseFIPS",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                            type: "tree",
+                                                                                                                                                            rules: [
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [
+                                                                                                                                                                        {
+                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                            argv: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                    argv: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                        },
+                                                                                                                                                                                        "supportsFIPS",
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                true,
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                    type: "tree",
+                                                                                                                                                                    rules: [
+                                                                                                                                                                        {
+                                                                                                                                                                            conditions: [],
+                                                                                                                                                                            endpoint: {
+                                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                                                                                                                                                                properties: {},
+                                                                                                                                                                                headers: {},
+                                                                                                                                                                            },
+                                                                                                                                                                            type: "endpoint",
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [],
+                                                                                                                                                                    error: "FIPS is enabled but this partition does not support FIPS",
+                                                                                                                                                                    type: "error",
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                        },
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [
+                                                                                                                                                                {
+                                                                                                                                                                    fn: "booleanEquals",
+                                                                                                                                                                    argv: [
+                                                                                                                                                                        {
+                                                                                                                                                                            ref: "UseDualStack",
+                                                                                                                                                                        },
+                                                                                                                                                                        true,
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                            type: "tree",
+                                                                                                                                                            rules: [
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [
+                                                                                                                                                                        {
+                                                                                                                                                                            fn: "booleanEquals",
+                                                                                                                                                                            argv: [
+                                                                                                                                                                                {
+                                                                                                                                                                                    fn: "getAttr",
+                                                                                                                                                                                    argv: [
+                                                                                                                                                                                        {
+                                                                                                                                                                                            ref: "PartitionResult",
+                                                                                                                                                                                        },
+                                                                                                                                                                                        "supportsDualStack",
+                                                                                                                                                                                    ],
+                                                                                                                                                                                },
+                                                                                                                                                                                true,
+                                                                                                                                                                            ],
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                    type: "tree",
+                                                                                                                                                                    rules: [
+                                                                                                                                                                        {
+                                                                                                                                                                            conditions: [],
+                                                                                                                                                                            endpoint: {
+                                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                                                                                                                                                                properties: {},
+                                                                                                                                                                                headers: {},
+                                                                                                                                                                            },
+                                                                                                                                                                            type: "endpoint",
+                                                                                                                                                                        },
+                                                                                                                                                                    ],
+                                                                                                                                                                },
+                                                                                                                                                                {
+                                                                                                                                                                    conditions: [],
+                                                                                                                                                                    error: "DualStack is enabled but this partition does not support DualStack",
+                                                                                                                                                                    type: "error",
+                                                                                                                                                                },
+                                                                                                                                                            ],
+                                                                                                                                                        },
+                                                                                                                                                        {
+                                                                                                                                                            conditions: [],
+                                                                                                                                                            endpoint: {
+                                                                                                                                                                url: "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dnsSuffix}",
+                                                                                                                                                                properties: {},
+                                                                                                                                                                headers: {},
+                                                                                                                                                            },
+                                                                                                                                                            type: "endpoint",
+                                                                                                                                                        },
+                                                                                                                                                    ],
+                                                                                                                                                },
+                                                                                                                                            ],
+                                                                                                                                        },
+                                                                                                                                        {
+                                                                                                                                            conditions: [],
+                                                                                                                                            error: "Operation Type is not set. Please contact service team for resolution.",
+                                                                                                                                            type: "error",
+                                                                                                                                        },
+                                                                                                                                    ],
+                                                                                                                                },
+                                                                                                                            ],
+                                                                                                                        },
+                                                                                                                        {
+                                                                                                                            conditions: [],
+                                                                                                                            error: "Partition: {arn#partition} from ARN doesn't match with partition name: {PartitionResult#name}.",
+                                                                                                                            type: "error",
+                                                                                                                        },
+                                                                                                                    ],
+                                                                                                                },
+                                                                                                            ],
+                                                                                                        },
+                                                                                                        {
+                                                                                                            conditions: [],
+                                                                                                            error: "Invalid ARN: Kinesis ARNs don't support `{arnType}` arn types.",
+                                                                                                            type: "error",
+                                                                                                        },
+                                                                                                    ],
+                                                                                                },
+                                                                                            ],
+                                                                                        },
+                                                                                        {
+                                                                                            conditions: [],
+                                                                                            error: "Invalid ARN: No ARN type specified",
+                                                                                            type: "error",
+                                                                                        },
+                                                                                    ],
+                                                                                },
+                                                                            ],
+                                                                        },
+                                                                        {
+                                                                            conditions: [],
+                                                                            error: "Invalid ARN: The ARN was not for the Kinesis service, found: {arn#service}.",
+                                                                            type: "error",
+                                                                        },
+                                                                    ],
+                                                                },
+                                                            ],
+                                                        },
+                                                        {
+                                                            conditions: [],
+                                                            error: "Invalid ARN: Invalid region.",
+                                                            type: "error",
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                        {
+                                            conditions: [],
+                                            error: "Invalid ARN: Invalid account id.",
+                                            type: "error",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "Invalid ARN: Failed to parse ARN.",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
                             argv: [
                                 {
                                     ref: "Endpoint",
                                 },
                             ],
-                            assign: "url",
                         },
                     ],
                     type: "tree",